<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE article PUBLIC "-//NLM//DTD JATS (Z39.96) Journal Archiving and Interchange DTD v1.3 20210610//EN"
                  "http://jats.nlm.nih.gov/archiving/1.3/JATS-archivearticle1-3.dtd">
<article xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink" dtd-version="1.3" article-type="other">
<front>
<journal-meta>
<journal-id></journal-id>
<journal-title-group>
<journal-title>forTEXT</journal-title>
</journal-title-group>
<issn publication-format="electronic">2943-212X</issn>
<publisher>
<publisher-name>Universitäts- und Landesbibliothek
Darmstadt</publisher-name>
<publisher-loc>Darmstadt</publisher-loc>
</publisher>
</journal-meta>
<article-meta>
<article-id pub-id-type="doi">10.48694/fortext.3753</article-id>
<title-group>
<article-title>Lerneinheit: CATMA-Annotationen auswerten mit
GitMA</article-title>
</title-group>
<contrib-group>
<contrib contrib-type="author">
<contrib-id contrib-id-type="orcid">0000-0002-7952-4194</contrib-id>
<name>
<surname>Schumacher</surname>
<given-names>Mareike</given-names>
</name>
<email>Mareike.Schumacher@sprachlit.uni-regensburg.de</email>
<xref ref-type="aff" rid="aff-1"/>
</contrib>
<contrib contrib-type="author">
<name>
<surname>Vauth</surname>
<given-names>Michael</given-names>
</name>
<email>michael.vauth@gmx.de</email>
</contrib>
<aff id="aff-1">
<institution-wrap>
<institution>Universität Regensburg</institution>
</institution-wrap>
</aff>
</contrib-group>
<pub-date date-type="pub" publication-format="electronic" iso-8601-date="2024-08-07">
<day>7</day>
<month>8</month>
<year>2024</year>
</pub-date>
<volume>1</volume>
<issue>4</issue>
<issue-title>Manuelle Annotation</issue-title>
<pub-history>
<event>
<event-desc>Erstveröffentlichung: 07.03.2022 auf <ext-link ext-link-type="uri" xlink:href="https://fortext.net/routinen/lerneinheiten/catma-annotationen-auswerten-gold-standard-erstellen-und-inter-annotator">fortext.net</ext-link>
<date date-type="origdate" iso-8601-date="2022-03-07">
<day>07</day>
<month>03</month>
<year>2022</year>
</date>
</event-desc>
</event>
</pub-history>
<permissions>
<license license-type="open-access">
<ali:license_ref xmlns:ali="http://www.niso.org/schemas/ali/1.0/">https://creativecommons.org/licenses/by-sa/4.0/</ali:license_ref>
<license-p>-This work is licensed under a Creative Commons
Attribution-ShareAlike 4.0 International License.</license-p>
</license>
</permissions>
</article-meta>
</front>
<body>
<p><bold>Erstveröffentlichung:</bold> 07.03.2022 auf <ext-link ext-link-type="uri" xlink:href="https://fortext.net/routinen/lerneinheiten/catma-annotationen-auswerten-gold-standard-erstellen-und-inter-annotator">fortext.net</ext-link></p>
<sec id="eckdaten-der-lerneinheit">
  <title>Eckdaten der Lerneinheit</title>
  <list list-type="bullet">
    <list-item>
      <p>Anwendungsbezug: Franz Kafkas <italic>Urteil</italic></p>
    </list-item>
    <list-item>
      <p>Methodik: Digitale, manuelle Annotation</p>
    </list-item>
    <list-item>
      <p>Angewendetes Tool: CATMA und GitHub sowie das Python-Package
      GitMA</p>
    </list-item>
    <list-item>
      <p>Lernziele: Laden eines Demo-Projektes aus CATMA, Überblick über
      Annotationen verschaffen, Annotationsdaten in Tabellen
      visualisieren, Goldstandard erstellen, IAA berechnen</p>
    </list-item>
    <list-item>
      <p>Dauer der Lerneinheit: 3 Stunden</p>
    </list-item>
    <list-item>
      <p>Schwierigkeitsgrad des Tools: mittel</p>
    </list-item>
  </list>
</sec>
<sec id="anwendungsbeispiel">
  <title>1. Anwendungsbeispiel</title>
  <p>Dieser Lerneinheit liegen CATMA-Annotationen (vgl.
  <xref alt="Annotation" rid="glossary-annotation">Annotation</xref>) zu
  Franz Kafkas <italic>Urteil</italic> zu Grunde. Die leitende
  Fragestellung der insgesamt zwei Annotatoren war: In welchen
  Textpassagen treten statische und prozesshafte Ereignisse auf?
  Zusätzlich zu den Annotationskategorien konnten die Eigenschaften
  „mental“, „persistent“, „intentional“ und „vorhersehbar“ jeweils mit
  einer binären ja-nein-Wertigkeit vergeben werden. Für die Auswertung
  von CATMA-Annotationen eignet sich das Tool GitMA
  (<xref alt="Vauth u. a. 2022" rid="ref-vauthGitMA2022" ref-type="bibr">Vauth
  u. a. 2022</xref>), ein Python-Package mit dem Sie direkt auf das
  Backend von CATMA
  (<xref alt="Schumacher 2024a" rid="ref-schumacherToolbeitragCATMA2019" ref-type="bibr">Schumacher
  2024a</xref>) zugreifen können.</p>
</sec>
<sec id="vorarbeiten">
  <title>2. Vorarbeiten</title>
  <p>Diese Lerneinheit wird mithilfe von Jupyter Notebooks
  (<xref alt="Kluyver u. a. 2016" rid="ref-kluyverJupyterNotebooksPublishing2016" ref-type="bibr">Kluyver
  u. a. 2016</xref>) ausgeführt. Ein solches Notebook ermöglicht es
  Ihnen, von uns vorbereitete kurze Code-Einheiten (vgl.
  <xref alt="Programmiercode" rid="glossary-code">Programmiercode</xref>)
  per Klick aufzurufen. Installieren Sie bitte vorab
  <ext-link ext-link-type="uri" xlink:href="https://web.archive.org/save/https://www.anaconda.com/products/individual">Anaconda</ext-link>
  (Anaconda Software Distribution 2020). Haben Sie Anaconda installiert,
  so nutzen Sie dieses Programm, um Git
  (<xref alt="Chacon und Straub 2014" rid="ref-chaconProGit2014" ref-type="bibr">Chacon
  und Straub 2014</xref>) zu installieren. Starten Sie dafür Anaconda
  und wechseln Sie links im Menü zu „Environments“. Geben Sie dann oben
  rechts in die Suchleiste „Git“ ein und wählen Sie im Drop-Down-Menü
  oben in der Mitte „All“. Im Suchergebnis erscheint nun eine Zeile für
  „Git – Distributed version control system“ vor der links ein leerer
  Kasten steht.</p>
  <fig>
    <caption><p>Abb. 1: Suche nach „Git“ innerhalb von
    Anaconda</p></caption>
    <graphic mimetype="image" mime-subtype="png" xlink:href="GitMA-Lerneinheit1.png" />
  </fig>
  <p>Klicken Sie in diesen Kasten, sodass dort ein kleiner Pfeil
  erscheint (vgl. Abb. 1) und gehen Sie dann auf den Button „Apply“
  unten rechts. Es kann einen Moment dauern bis das Programm Ihnen
  anzeigt, was die Installation von GitMA bedeutet, bzw. welche anderen
  Packages zusätzlich installiert oder aktualisiert werden müssen.
  Sobald Ihnen die Liste angezeigt wird, können Sie mit „Apply“ die
  Installation bestätigen (vgl. Abb. 2).</p>
  <fig>
    <caption><p>Abb. 2: Installation von Git innerhalb von
    Anaconda</p></caption>
    <graphic mimetype="image" mime-subtype="png" xlink:href="GitMA-Lerneinheit2.png" />
  </fig>
  <p>Außer Git benötigen Sie für diese Lerneinheit noch das
  Python-Package „Pip“. Prüfen Sie, ob dieses Packet installiert werden
  muss, indem Sie oben rechts in der Suchleiste auf das Kreuz klicken.
  Geben Sie nun „Pip“ ein. Wenn im Suchergebnis vor „Pip – Pypa
  recommended tool for installing python packages“ noch kein grünes
  Häkchen steht, installieren Sie es ebenso wie Git. Im vierten Teil
  dieser Lerneinheit erfahren Sie, wie Sie bei einer kollaborativen
  Annotation
  (<xref alt="Jacke 2024a" rid="ref-jackeMethodenbeitragKollaborativesLiteraturwissenschaftliches2018" ref-type="bibr">Jacke
  2024a</xref>) die Übereinstimmung zwischen zwei oder mehr
  Annotator*innen in Form eines Gamma-Wertes bestimmen können. Ebenso
  wie GitMA kann das hierfür notwendige Python Package „Pygamma“
  (<xref alt="Titeux und Riad 2021" rid="ref-titeuxPygammaagreementGammaMeasure2021" ref-type="bibr">Titeux
  und Riad 2021</xref>) nicht über die grafische Benutzeroberfläche
  installiert werden. Darum öffnen Sie nun bitte in Anaconda eine
  <xref alt="Commandline" rid="glossary-commandline">Commandline</xref>.
  Gehen Sie dazu links im Menü zurück zu „Environments“ und klicken Sie
  auf den Play-Button hinter „Base (root)“. Gehen Sie dann auf „Open
  Terminal“ (vgl. Abb 3).</p>
  <fig>
    <caption><p>Abb. 3: Öffnen einer Commandline in
    Anaconda</p></caption>
    <graphic mimetype="image" mime-subtype="png" xlink:href="GitMA-Lerneinheit3.png" />
  </fig>
  <p>Zuerst installieren Sie Pygamma, indem Sie folgenden Code kopieren,
  in die Kommandozeile einfügen und mit Enter bestätigen:</p>
  <code language="python">pip install pygamma-agreement</code>
  <p>Um GitMA zu installieren, geben Sie dann bitte folgenden Code
  ein:</p>
  <code language="python">pip install git+&lt;https://github.com/forTEXT/gitma&gt;</code>
  <p>Laden Sie nun unser CATMA-Demo-Projekt sowie die Jupyter Notebooks
  zur Nutzung von GitMA herunter. Gehen Sie dazu in unser
  <ext-link ext-link-type="uri" xlink:href="https://web.archive.org/save/https://github.com/forTEXT/gitma">GitMA-GitHub-Repository</ext-link>
  und dort zunächst auf den grünen Button „Code“ und dann auf „Download
  ZIP“ (vgl. Abb. 4). Wiederholen Sie das gleiche mit dem
  <ext-link ext-link-type="uri" xlink:href="https://web.archive.org/save/https://github.com/forTEXT/forTEXT.net">forTEXT.net-GitHub-Repository</ext-link>.
  Entpacken Sie dann die
  <xref alt="ZIP" rid="glossary-zip">ZIP</xref>-Archive, indem Sie sie
  in Ihrem Ordnersystem ausfindig machen und dann doppelt draufklicken.
  Kopieren Sie aus dem forTEXT.net-Ordner die vier Notebooks
  „Annotationen auswerten mit GitMA 1-4“ in den Unterordner des
  GitMA-Ordners mit dem Namen „demo_notebooks“.</p>
  <fig>
    <caption><p>Abb. 4: Download des GitMA-Demo-Projektes und der
    dazugehörigen Jupyter Notebooks</p></caption>
    <graphic mimetype="image" mime-subtype="png" xlink:href="GitMA-Lerneinheit4.png" />
  </fig>
  <p>Wenn Sie mit eigenen Daten arbeiten wollen, so müssen Sie diese
  zunächst in einer manuellen Annotation
  (<xref alt="Jacke 2024b" rid="ref-jackeMethodenbeitragManuelleAnnotation2018" ref-type="bibr">Jacke
  2024b</xref>) mit CATMA erstellen. Wie Sie solche Annotationsdaten
  anlegen können, erfahren Sie in unserer Lerneinheit zur manuellen
  Annotation mit CATMA
  (<xref alt="Horstmann 2024" rid="ref-horstmannLerneinheitManuelleAnnotation2019" ref-type="bibr">Horstmann
  2024</xref>). Wenn Sie ausschließlich mit dem von uns bereitgestellten
  Demo-Projekt arbeiten wollen, so können Sie im nächsten Abschnitt
  direkt zur Funktion der Annotationsexploration springen. Wenn Sie
  erfahren möchten, wie Sie den Zugang zu Ihren eigenen CATMA-Projekten
  herstellen können, so fahren Sie einfach mit dem nächsten Schritt
  fort.</p>
</sec>
<sec id="funktionen">
  <title>3. Funktionen</title>
  <p>Mit GitMA können Sie zahlreiche Formen der Annotationsauswertung
  vornehmen. In dieser Lerneinheit zeigen wir Ihnen in vier thematischen
  Blöcken, wie Sie Projekte aus CATMA laden können, wie Sie Ihre
  Annotationsdaten explorieren, wie Sie die Erstellung eines Gold
  Standard unterstützen können und wie Sie ein Inter-Annotator-Agreement
  berechnen können.</p>
  <sec id="annotationsdaten-aus-catma-laden">
    <title>Annotationsdaten aus CATMA laden</title>
    <p>Wechseln Sie nun in Anaconda links im Menü von „Environments“ zu
    „Home“ und klicken Sie in der Kachel „Jupyter Notebook“ auf den
    „Launch“-Button. Ihnen wird nun in Ihrem
    <xref alt="Browser" rid="glossary-browser">Browser</xref> Ihr
    Ordnersystem angezeigt. Gehen Sie zu dem Ordner, in dem Sie das
    GitMA-Repository von GitHub gespeichert haben. Klicken Sie auf den
    Ordner „gitma-main“ und öffnen Sie dann den Ordner „Annotationen
    auswerten mit GitMA-Notebooks“, den Sie zuvor hierher verschoben
    haben (s.o.) und dann das erste Notebook „Annotationen auswerten mit
    GitMA 1“, indem Sie einfach darauf klicken. Das erste Notebook
    öffnet sich dann in einem neuen Browser-Tab (vgl. Abb. 5). Folgen
    Sie am besten den Anleitungen direkt im Notebook. Falls Sie eine
    Auswahl unserer Codebeispiele lieber zu einem eigenen Notenbook
    zusammenfassen wollen, finden Sie die einzelnen Schritte im
    Folgenden dokumentiert.</p>
    <fig>
      <caption><p>Abb. 5: Jupyter Notebook zum Laden von CATMA-Daten
      über GitMA</p></caption>
      <graphic mimetype="image" mime-subtype="png" xlink:href="GitMA-Lerneinheit5.png" />
    </fig>
    <p>Im ersten Teil unserer Lerneinheit erfahren Sie, wie Sie Ihr
    CATMA-Profil mit GitMA laden und einzelne Projekte klonen. Außerdem
    zeigen wir Ihnen, wie Sie einige Statistiken Ihres Projektes
    einsehen können. Mehr über die Annotation mit CATMA finden Sie im
    forTEXT-Methodenbeitrag zur manuellen Annotation
    (<xref alt="Jacke 2024b" rid="ref-jackeMethodenbeitragManuelleAnnotation2018" ref-type="bibr">Jacke
    2024b</xref>) und in unserer Lerneinheit zur manuellen Annotation
    mit CATMA
    (<xref alt="Horstmann 2024" rid="ref-horstmannLerneinheitManuelleAnnotation2019" ref-type="bibr">Horstmann
    2024</xref>).</p>
  </sec>
  <sec id="catma-importieren">
    <title>1. CATMA importieren</title>
    <p>Um auf die Verbindung zwischen GitHub und CATMA zugreifen zu
    können, müssen Sie im ersten Schritt CATMA importieren. Dazu können
    Sie folgenden Code nutzen:</p>
    <code language="python">from gitma import Catma</code>
  </sec>
  <sec id="catma-profil-laden">
    <title>2. CATMA Profil laden</title>
    <p>Sie können Ihr CATMA-Profil ganz einfach über ein sogenanntes
    Access Token für GitMA zugänglich machen. Um ein Acess Token zu
    erstellen, öffnen Sie Ihren CATMA-Account und klicken Sie auf das
    Profil-Icon oben rechts (vgl. Abb. 6). Es öffnet sich ein Menü, in
    dem Sie „Get Access Token“ auswählen können.</p>
    <fig>
      <caption><p>Abb. 6: Access Token im CATMA-Profil
      anfordern</p></caption>
      <graphic mimetype="image" mime-subtype="png" xlink:href="access_token_ui.PNG" />
    </fig>
    <p>Es öffnet sich nun ein Fenster, in dem Sie das Access Token
    benennen können. Sie können den Zugang Ihres Tokens zeitlich
    beschränken oder unbeschränkten Zugang gewähren (vgl. Abb. 7).
    Behalten Sie im Hinterkopf, dass mit diesem Token Zugang zu Ihren
    gesamten CATMA-Daten gewährt wird. Verwalten Sie in CATMA sensible
    Daten, so achten Sie darauf, das Access Token nicht weiterzugeben.
    Sie können immer wieder neue Access Tokens generieren.</p>
    <fig>
      <caption><p>Abb. 7: Access Token benennen und zeitlich
      beschränken</p></caption>
      <graphic mimetype="image" mime-subtype="png" xlink:href="Bildschirmfoto_2022-02-23_um_09.13.33.png" />
    </fig>
    <p>Sie können Access Tokens auch im CATMA-GitLab generieren. Loggen
    Sie sich dazu
    <ext-link ext-link-type="uri" xlink:href="https://web.archive.org/save/https://git.catma.de/">auf
    CATMA GitLab</ext-link> mit Ihren CATMA-Account-Daten ein und nutzen
    Sie die <xref alt="API" rid="glossary-api">API</xref>-Settings (vgl.
    Abb. 8).</p>
    <fig>
      <caption><p>Abb. 8: API-Settings im CATMA-GitLab
      nutzen</p></caption>
      <graphic mimetype="image" mime-subtype="png" xlink:href="access_token_gitlab.PNG" />
    </fig>
    <p>Nutzen Sie dann den folgenden Code, um Ihr CATMA-Projekt zu
    laden.</p>
    <code language="python">your_access_token = ''  
my_catma = Catma(gitlab_access_token=your_access_token)

# Um eine Liste Ihrer Projekte einzusehen, können Sie den Befehl nutzen:

my_catma.project_name_list</code>
  </sec>
  <sec id="catma-projekt-klonen-und-laden">
    <title>3. CATMA-Projekt klonen und laden</title>
    <p>Mit den vorangehenden Schritten haben Sie die Verbindung zu Ihrem
    CATMA-Profil hergestellt. Diese Verbindung können Sie nutzen, um
    einzelne Projekte zu klonen, d.h. lokal auf Ihrem Rechner zu
    speichern. Diese lokal gespeicherten Daten können Sie mithilfe von
    GitMA laden und analysieren. Um ein Projekt zu klonen, brauchen Sie
    lediglich dessen Namen.
    Um Ihr Projekt zu klonen und zu laden, passen Sie untenstehenden
    Code so an, dass zwischen den einfachen Anführungsstrichen, in denen
    jetzt „test_corpus“ steht, Ihr Projektname eingesetzt wird. Einen
    Ordner, in dem das Projekt gespeichert werden soll, können Sie in
    der Zeile darunter zwischen den einfachen Anführungsstrichen
    angeben, dort, wo jetzt „../projects/“ steht.</p>
    <code language="python">my_catma.load_project_from_gitlab(  
project_name='',  
backup_directory='../projects/'  
)</code>
    <p><bold><italic>Aufgabe 1</italic></bold>: In welcher Spalte der
    Tabelle finden Sie Ihre Tagsets?</p>
    <p>Sie haben hier eine Fehlermeldung erhalten? Beim ersten Laden
    kann es sein, dass der Zugang direkt vom Jupyter Notenbook aus nicht
    zustande kommt. Fahren Sie darum mit Punkt 5.1 fort und kehren Sie
    dann hierher zurück.</p>
  </sec>
  <sec id="projekt-statistiken-einsehen">
    <title>4. Projekt-Statistiken einsehen</title>
    <p>Sie haben über das Access Token eine Verbindung zu Ihrem
    CATMA-Account hergestellt und ein Projekt geklont. Um sich einige
    grundsätzliche Statistiken Ihres Projektes in einer Tabelle
    anzusehen, führen Sie den folgenden Code aus. Geben Sie dazu
    zunächst den Namen Ihres Projektes zwischen den einfachen
    Anführungsstrichen ein und klicken Sie dann oben im Menü auf
    „Run“.</p>
    <code language="python">my_catma.project_dict[''].stats()</code>
  </sec>
  <sec id="zusätzliche-funktionen">
    <title>5. Zusätzliche Funktionen</title>
    <p>Mithilfe des ersten Jupyter Notebooks dieser Lerneinheit können
    Sie die Auswertung Ihrer Annotationen mit GitMA vorbereiten. Um
    weitere Analysen durchführen zu können, fahren Sie bitte mit dem 2.
    Demo-Notebook „Annotationen auswerten mit GitMA 2“ dieser Einheit
    fort. Falls Sie Ihr Projekt lieber manuell über ein Terminal (vgl.
    <xref alt="Commandline" rid="glossary-commandline">Commandline</xref>)
    klonen möchten oder alle Ihre Projekte laden, so finden Sie
    hierunter noch zwei zusätzliche Zeilen Code, die Sie dafür nutzen
    können.</p>
  </sec>
  <sec id="projekt-über-das-terminal-klonen">
    <title>5.1 Projekt über das Terminal klonen</title>
    <p>Indem Sie den folgenden Code ausführen, erhalten Sie eine Zeile
    Code in einfachen Anführungsstrichen. Kopieren Sie diesen (ohne
    Anführungszeichen) in die Zwischenablage. Gehen Sie dann zurück zu
    Anaconda und wechseln Sie dort im Menü auf „Environment“ und klicken
    Sie auf den Play-Button hinter „Base (root)“. Gehen Sie dann auf
    „Open Terminal“ und kopieren Sie den Code aus Ihrer Zwischenablage
    hier hinein. Drücken Sie nun „Enter“, so wird der Download Ihres
    CATMA-Projektes gestartet. Ist es der erste Download aus einem
    CATMA-Account, so werden Sie aufgefordert, zuerst Ihren
    Benutzernamen und dann Ihr Passwort einzugeben (Achtung: Beim
    Eingeben des Passworts werden die Buchstaben aus Sicherheitsgründen
    nicht angezeigt). Drücken Sie nach Passworteingabe auf „Enter“, so
    startet der Download. Haben Sie diesen Schritt ausgeführt, da Sie
    bei Punkt „3. CATMA Projekt klonen und laden“ eine Fehlermeldung
    erhalten haben, so können Sie bei folgenden Downloads ab jetzt
    einfach den Code unter 3. im ersten Notebook dieser Lerneinheit
    ausführen. Die Eingabe der Benutzerdaten muss nur einmal
    erfolgen.</p>
    <code language="python">my_catma.git_clone_command(project_name='')</code>
  </sec>
  <sec id="alle-catma-projekte-eines-accounts-laden">
    <title>5.2 Alle CATMA-Projekte eines Accounts laden</title>
    <p>Den folgenden Code können Sie nutzen, um all Ihre CATMA-Projekte
    zu laden. Nutzen Sie diese Funktion <bold>vorsichtig</bold>, denn
    bei vielen und / oder großen Projekten kann das Laden sehr lange
    dauern.</p>
    <code language="python">my_catma.load_all_projects_from_gitlab</code>
  </sec>
  <sec id="annotationsdaten-explorieren">
    <title>Annotationsdaten explorieren</title>
    <p>Im zweiten Teil dieser Lerneinheit nutzen wir ein
    CATMA-Demo-Projekt, um einige generelle statistische Eigenschaften
    zu betrachten. Mithilfe des zweiten Notebooks lernen Sie außerdem
    einige grundlegende Möglichkeiten der Visualisierung
    (<xref alt="Horstmann und Stange 2024" rid="ref-horstmannMethodenbeitragTextvisualisierung2018" ref-type="bibr">Horstmann
    und Stange 2024</xref>) Ihrer Annotationsdaten kennen. Sie lernen,
    unterschiedliche <italic>Annotation Collections</italic> zu
    visualisieren und wie Sie <italic>Tags</italic> und
    <italic>Properties</italic> (vgl.
    <xref alt="Property" rid="glossary-property">Property</xref>)
    grafisch darstellen lassen können. Um diese Funktionen mit eigenen
    Annotationsdaten ausführen zu können, müssen Sie diese mit dem
    Annotationstool CATMA erstellt haben. Wie Sie in CATMA annotieren,
    erfahren Sie in der forTEXT-Lerneinheit zur manuellen Annotation mit
    CATMA
    (<xref alt="Horstmann 2024" rid="ref-horstmannLerneinheitManuelleAnnotation2019" ref-type="bibr">Horstmann
    2024</xref>).
    Um eigene CATMA-Annotationsdaten auswerten zu können, müssen diese
    außerdem zuerst lokal auf Ihrem Computer gespeichert werden. Wie Sie
    das mit GitMA machen können, erfahren Sie im ersten Teil dieser
    Lerneinheit.</p>
  </sec>
  <sec id="catma-projekt-laden">
    <title>1. CATMA-Projekt laden</title>
    <p>Ein CATMA-Projekt besteht aus Dokumenten, in denen Text abgelegt
    ist, Tagsets (vgl.
    <xref alt="Tagset" rid="glossary-tagset">Tagset</xref>), in denen
    die Annotationskategorien abgelegt sind und Collections, in denen
    die Positionen und Tags der Annotationen pro Text und Annotator*in
    abgelegt sind. Diese komplexe Struktur können Sie mit GitMA laden,
    indem Sie den Code in der folgenden Zeile ausführen.</p>
    <code language="python">from gitma import CatmaProject</code>
    <p>Als nächstes müssen Sie spezifizieren, welches Projekt genau
    geladen werden soll und wo es im Ordnersystem Ihres Computers zu
    finden ist. Um das Demo-Projekt zu nutzen, müssen Sie in
    untenstehendem Code nichts verändern.
    Wenn Sie eigene CATMA-Daten nutzen wollen, so ändern Sie in den
    einfachen Anführungsstrichen, in denen jetzt „../test/demo_project/“
    steht, den Dateipfad ab, indem Sie den Pfad zum Ordner eingeben, in
    dem Ihr CATMA-Projekt abgelegt wurde. Haben Sie im ersten Teil
    dieser Lerneinheit einen eigenen Backup-Ordner angelegt, so geben
    Sie jetzt hier den Pfad zu genau diesem Ordner ein, also z.B.
    „../gitma_demo/catma-backup“. In die einfachen Anführungsstriche, in
    denen jetzt „test_corpus“ steht, geben Sie den Namen Ihres
    CATMA-Projektes ein.</p>
    <code language="python">my_project = CatmaProject(  
      project_directory='../test/demo_project/',  
      project_name='test_corpus'  
      )</code>
  </sec>
  <sec id="generelle-statistiken-aufrufen">
    <title>2. Generelle Statistiken aufrufen</title>
    <p>Wenn Sie sich einen Überblick darüber verschaffen wollen, wie
    viele Annotationen in Ihrem Projekt sind, wer aus dem Team wie viele
    davon erstellt hat und welche Tags verwendet wurden, so können Sie
    sich dafür eine Tabelle anzeigen lassen. Nutzen Sie dazu den
    folgenden Code:</p>
    <code language="python">my_project.stats()</code>
  </sec>
  <sec id="einen-überblick-über-die-annotationen-eines-projektes-bekommen">
    <title>3. Einen Überblick über die Annotationen eines Projektes
    bekommen</title>
    <p>Sie können Ihre Annotationen in einer interaktiven Visualisierung
    grafisch darstellen. Mit der hier gezeigten Funktion wird jedes
    Dokument einzeln angezeigt. Das heißt, wenn Sie zu zweit zwei Texte
    annotiert haben, so erhalten Sie zwei Grafiken. Da in unserem
    Demo-Projekt nur ein Text annotiert wurde, erhalten Sie nur eine
    Grafik, wenn Sie dieses Projekt nutzen. Sie können wählen, wofür die
    farbliche Darstellung in der Visualisierung stehen soll. Im ersten
    Beispiel sind dies die <italic>Annotation Collections</italic>, im
    zweiten eine <italic>Property</italic> der Annotationen und im
    dritten die Annotator*innen.</p>
    <code language="python">my_project.plot_interactive()</code>
    <p><bold><italic>Aufgabe 2</italic></bold>: Vergleichen Sie die
    beiden Visualisierungen. Welche Textstelle wurde in einer
    <italic>Annotation Collection</italic> als <italic>Stative
    Event</italic> und in der anderen als <italic>Process</italic>
    annotiert?
    Wenn Sie statt der <italic>Annotation Collections</italic> lieber
    die Verwendung einer <italic>Property</italic> farbig darstellen
    wollen, nutzen Sie dazu den folgenden Code:</p>
    <code language="python">my_project.plot_interactive(color_col='prop:intentional')</code>
    <p><bold><italic>Aufgabe 3</italic></bold>: Wie viele Annotationen
    weisen die <italic>Property</italic> „intentional“ nicht auf?
    Statt der Annotator*innen und der <italic>Annotation
    Collections</italic> können Sie auch die <italic>Tags</italic>
    visualisieren. Nutzen Sie dazu die folgende Code-Zeile:</p>
    <code language="python">my_project.plot_interactive(color_col='annotator')</code>
    <p><bold><italic>Aufgabe 4</italic></bold>: Aus der Tabelle unter
    „2. Generelle Statistiken aufrufen“ können Sie ablesen, dass beide
    Annotatoren jeweils sechs Annotationen gemacht haben. Wie erklären
    Sie sich, dass hier nur insgesamt acht Annotationen angezeigt
    werden?</p>
  </sec>
  <sec id="spezifische-annotation-collections-visualisieren">
    <title>4. Spezifische Annotation Collections visualisieren</title>
    <p>Wenn Sie nur eine bestimmte <italic>Annotation
    Collection</italic>, d.h. nur die Annotationen eines einzigen
    Team-Mitglieds, visualisieren möchten, so können Sie dazu die
    untenstehende Funktion nutzen. Dargestellt sind auf der y-Achse die
    <italic>Tags</italic>, also die Annotationskategorien, und auf der
    x-Achse die Positionen im Text (in Zeichen, d.h., Position 500
    bedeutet nicht Seite 500, sondern das 500. Zeichen im Text). Die
    Annotationen sind nach Tags (Farbe) und Umfang (Größe) einmal als
    Punkte im Koordinatensystem und einmal oberhalb desselben
    visualisiert. Oben sehen Sie, wie die Annotationen sich über den
    Text erstrecken und einander auch überlappen. Sowohl im
    Koordinatensystem als auch darüber können Sie die
    Maus-Hover-Funktion nutzen, um mehr Informationen zu erhalten.
    Führen Sie Ihre Maus z.B. über die zweite Annotation eines
    „stative_event“ im Koordinatensystem, so erfahren sie u.a. die Größe
    der Annotation und auch den genauen Text, der annotiert worden ist.
    Wenn Sie eigene CATMA-Daten für Visualisierungen dieser Art nutzen,
    so ersetzen Sie „ac_2“ in den einfachen Anführungszeichen durch den
    Namen der <italic>Annotation Collection</italic>, die Sie
    untersuchen möchten.</p>
    <code language="python">my_project.ac_dict['ac_2'].plot_annotations()</code>
    <p>Sie können die Visualisierung anpassen, sodass sie anzeigt, ob
    Annotationen bestimmte <italic>Properties</italic> aufweisen. In
    unserem Beispielprojekt gibt es z.B. die Eigenschaft „mental“ für
    die annotierten Events. Mit dem folgenden Code können Sie sichtbar
    machen, welche der annotierten Events auf mentale Ereignisse
    referieren.</p>
    <code language="python">my_project.ac_dict['ac_2'].plot_annotations(y_axis='prop:mental')</code>
    <p>Wenn Sie nachvollziehen möchten, ob die Annotator*innen
    <italic>Properties</italic> unterschiedlich verwendet haben, so
    können Sie mit folgendem Code die Annotator*innen auf der y-Achse
    und die Annotationen auf der x-Achse anzeigen lassen. Die Farbe
    zeigt die Verwendung der <italic>Property</italic> an (hier:
    Unvorhersehbarkeit der annotierten Events). In unserem
    Beispielprojekt hat keiner der Annotatoren ein Event als
    unvorhersehbar klassifiziert.</p>
    <code language="python">my_project.ac_dict['ac_2'].plot_annotations(  
      y_axis='annotator',  
      color_prop='prop:unpredictable'  
      )</code>
    <p><bold><italic>Aufgabe 5</italic></bold>: Statische oder
    Prozess-Events: Mit welcher Annotationskategorie wurde die längste
    Textpassage annotiert und wie viele Zeichen umfasst diese?</p>
  </sec>
  <sec id="kookurrenznetzwerke-von-annotationen-darstellen">
    <title>5. Kookurrenznetzwerke von Annotationen darstellen</title>
    <p>Sie können Ihre Annotationen als Netzwerke (mehr zur Methode der
    digitalen Netzwerkanalyse sieh Schumacher
    (<xref alt="2024b" rid="ref-schumacherMethodenbeitragNetzwerkanalyse2018" ref-type="bibr">2024b</xref>))
    darstellen, indem Sie z.B. immer die am nächsten zueinanderstehenden
    Annotationskategorien berechnen lassen. Auf diese Weise bekommen Sie
    einen übergeordneten Blick auf Ihre Annotationskategorien. Sie
    können den folgenden Code ohne Anpassung ausführen, um mit unseren
    Beispieldaten ein sehr einfaches Netzwerk darzustellen. Wenn Sie mit
    eigenen Projektdaten arbeiten, so tauschen Sie „ac_1“ gegen den
    Namen einer Ihrer <italic>Annotation Collections</italic> aus.</p>
    <code language="python">my_project.ac_dict['ac_1'].cooccurrence_network()</code>
    <p>Sie können das Netzwerk anpassen, indem Sie folgende Parameter
    hinzufügen und ggf. abändern:</p>
    <list list-type="bullet">
      <list-item>
        <p>character_distance: Textspanne, in der sich zwei als
        kookurrent interpretierte Annotationen max. befinden können
        (Default Wert sind hier 100 Zeichen)</p>
      </list-item>
      <list-item>
        <p>included_tags: Tags, die in die Netzwerkerstellung einbezogen
        werden sollen (in Form einer Liste)</p>
      </list-item>
      <list-item>
        <p>excluded_tags: Tags, die nicht in die Netzwerkerstellung
        einbezogen werden sollen (in Form einer Liste oder „None“, wenn
        keine Tags ausgeschlossen werden sollen)</p>
      </list-item>
    </list>
    <p>Da unser bisher genutztes Demo-Projekt zu wenig Daten beinhaltet,
    um ein derart modifiziertes Netzwerk abzubilden, haben wir einen
    anderen Datensatz als Beispiel aufbereitet.
    Wenn Sie mit eigenen Daten arbeiten, passen Sie wieder den Namen der
    <italic>Annotation Collection</italic> (hier: ac_1) an. Die übrigen
    Werte können Sie unverändert stehen lassen oder abändern, je nach
    Bedarf. Wenn Sie die Listen der berücksichtigten und
    ausgeschlossenen Tags erweitern wollen, vergessen Sie nicht, jeden
    hinzugefügten Tag in einfache Anführungsstriche zu setzen und mit
    einem Komma von dem vorigen zu trennen.</p>
    <code language="python">my_project.ac_dict['ac_1'].cooccurrence_network(  
      character_distance=50,  
      included_tags=['process', 'stative_event'],  
      excluded_tags=None  
      )</code>
  </sec>
  <sec id="annotation-collections-als-pandas-dataframe-darstellen">
    <title>6. Annotation Collections als Pandas DataFrame
    darstellen</title>
    <p>Mit der nächsten Funktion können Sie die Annotationen einer
    <italic>Annotation Collection</italic> und deren Kontexte in einer
    Tabelle darstellen. Wie bei den Visualisierungen im vorigen
    Abschnitt, können Sie entweder mit dem Demo-Projekt arbeiten und den
    Code unverändert ausführen oder mit eigenen CATMA-Daten arbeiten.
    Wenn Sie mit eigenen CATMA-Daten arbeiten, ersetzen Sie einfach
    wieder „ac_2“ durch den Namen einer Ihrer <italic>Annotation
    Collections</italic>.</p>
    <code language="python">my_project.ac_dict['ac_2'].df</code>
    <p><ext-link ext-link-type="uri" xlink:href="https://web.archive.org/save/https://pandas.pydata.org/docs/index.html">Pandas</ext-link>
    (<xref alt="McKinney u. a. 2010" rid="ref-mckinneyDataStructuresStatistical2010" ref-type="bibr">McKinney
    u. a. 2010</xref>) ist eine vielseitige und populäre Python Library
    um quantitative Analysen größerer Datenmengen durchzuführen. Als
    pandas DataFrame können Annotation Collections auch in
    unterschiedlichen Datenformaten gespeichert werden; zum Beispiel
    tabellarisch als
    <xref alt="CSV" rid="glossary-csv">CSV</xref>-Dateien:</p>
    <code language="python">my_project.ac_dict['ac_2'].df.to_csv('annotations.csv')</code>
    <p>oder als <xref alt="JSON" rid="glossary-json">JSON</xref>
    Dateien:</p>
    <code language="python">my_project.ac_dict['ac_2'].df.to_json('annotations.json')</code>
    <p>In dieser Form lassen sich CATMA-Annotationen auch gut
    nachnutzbar veröffentlichen.</p>
  </sec>
  <sec id="tags-analysieren">
    <title>6.1 Tags analysieren</title>
    <p>Möchten Sie herausfinden, wie viele Annotationen jeweils mit
    einem Tag gemacht wurden, wie viel Text jeweils mit einem Tag belegt
    wurde, wie die durchschnittliche Länge einer Annotation mit einem
    Tag ist und welche Wörter darin am häufigsten vorkommen? All das
    können Sie mit der nächsten Funktion machen. Wie gehabt, arbeiten
    Sie mit dem Demo-Projekt, wenn Sie den Code unverändert lassen. Wenn
    Sie mit eigenen Daten arbeiten, fügen Sie wieder den Namen Ihrer
    eigenen <italic>Annotation Collection</italic> ein. Sie können
    außerdem die Anzahl der häufigsten Tokens (vgl.
    <xref alt="Type/Token" rid="glossary-type-token">Type/Token</xref>)
    eines Tags, die aufgelistet werden soll, anpassen. Um dies zu tun,
    ersetzen Sie die 5 beim „ranking“ durch eine andere Zahl.</p>
    <code language="python">my_project.ac_dict['ac_2'].tag_stats(ranking=5)</code>
    <p>Wenn Sie <italic>Properties</italic> verwendet haben, so können
    Sie die Funktion auch so anwenden, dass Ihnen nur Annotationen
    aufgelistet werden, bei denen eine bestimmte
    <italic>Property</italic> verwendet wurde. In untenstehendem
    Beispiel werden nur Annotationen von Events berücksichtigt, bei der
    die <italic>Property</italic> „mental“ genutzt wurde. In den Reihen
    zeigen sich die unterschiedlichen Werte der
    <italic>Property</italic>, die vergeben wurden (hier „no“ und
    „yes“). Beim Ranking werden die 3 häufigsten Wörter berücksichtigt
    und es werden Stopwörter (vgl.
    <xref alt="Stoppwortliste" rid="glossary-stoppwortliste">Stoppwortliste</xref>)
    ausgeschlossen. Außerdem können Sie weitere Wörter ergänzen. Setzen
    Sie dabei jedes Wort in einfache Anführungsstriche und trennen Sie
    die Wörter mit einem Komma. Wie bei den vorherigen Code-Beispielen,
    können Sie auch hier wieder mit eigenen Daten arbeiten und „ac_2“
    durch den Namen einer Ihrer <italic>Annotation Collections</italic>
    ersetzen.</p>
    <code language="python">my_project.ac_dict['ac_2'].tag_stats(tag_col='prop:mental', ranking=3, stopwords=['in', 'im'])</code>
    <p>Wenn Sie möchten, dass in den Reihen nicht die Property Values,
    sondern die Annotator*innen angegeben werden, so nutzen Sie den
    folgenden Code. Es werden im Beispiel die drei häufigsten Wörter in
    die Analyse einbezogen. Auch hier kann bei Bedarf „ac_2“ wieder
    durch den Namen einer eigenen <italic>Annotation Collection</italic>
    ersetzt werden.</p>
    <code language="python">my_project.ac_dict['ac_2'].tag_stats(tag_col='annotator', ranking=3)</code>
  </sec>
  <sec id="properties-analysieren">
    <title>6.2 <italic>Properties</italic> analysieren</title>
    <p>Wenn Sie die Nutzung aller <italic>Properties</italic> und deren
    Wertung analysieren wollen, so können Sie das mit der folgenden
    Funktion tun. Wenn Sie mit eigenen Daten arbeiten, ersetzen Sie wie
    gehabt „ac_2“.</p>
    <code language="python">my_project.ac_dict['ac_2'].property_stats()</code>
    <p><bold><italic>Aufgabe 6</italic></bold>: Wie viele Events wurden
    als <italic>intentional</italic> klassifiziert, wie viele als
    <italic>nicht-intentional</italic> und bei wie vielen Annotationen
    wurde diese <italic>Property</italic> nicht mit einem Wert
    versehen?</p>
    <p>Ein Projekt laden, sich einen Überblick darüber verschaffen,
    <italic>Annotation Collections</italic> visualisieren und Tags und
    deren <italic>Properties</italic> analysieren – all das können Sie
    nun bereits mithilfe von GitMA tun. Im nächsten Teil dieser
    Lerneinheit zeigen wir Ihnen, wie Sie mit GitMA eine
    Goldstandard-Annotation erstellen und in Ihr Projekt in CATMA
    hochladen können. Um mit dem dritten Teil der Lerneinheit zu
    beginnen, öffnen Sie bitte das Jupyter Notebook mit dem Namen
    „Annotationen auswerten mit GitMA 3“.</p>
  </sec>
  <sec id="goldstandard-annotationen-automatisch-erstellen-mit-gitma">
    <title>Goldstandard-Annotationen automatisch erstellen mit
    GitMA</title>
    <p>Wir wenden uns nun der Erstellung eines Goldstandards für
    Annotationen zu, die Sie in CATMA erstellt haben. Diese Daten
    erstellen Sie zunächst lokal auf Ihrem Computer, können Sie dann
    aber zurück in die CATMA-Webapplikation laden.
    Der dritte Teil dieser Lerneinheit nutzt wieder ein von uns
    erstelltes Beispielprojekt. Wie Sie eigene CATMA-Daten auf Ihren
    Computer herunterladen können, zeigen wir Ihnen im ersten Teil, dem
    Notebook mit dem Dateinamen „Annotationen auswerten mit GitMA
    1“.</p>
  </sec>
  <sec id="einführung-in-die-erstellung-eines-goldstandards-mit-gitma">
    <title>1. Einführung in die Erstellung eines Goldstandards mit
    GitMA</title>
    <p>Um Goldannotationen zu erstellen, kann mit GitMA eine Kopie aller
    übereinstimmenden Annotationen von zwei Annotator*innen angefertigt
    werden. Diese übereinstimmenden Annotationen werden in einer (neuen)
    <italic>Gold Annotation Collection</italic> abgelegt. Diese neue
    <italic>Annotation Collection</italic> können Sie über Git wieder in
    CATMA hochladen, wo Sie sie dann wie gewohnt bearbeiten können,
    d.h., Sie können hier Annotationen hinzufügen und die automatisch
    erstellten Gold Annotationen überarbeiten.
    In CATMA können Sie ganz frei und undogmatisch annotieren, was dazu
    führt, dass Annotationsspannen stark variieren können. Bei der
    Erstellung eines Goldstandards mit GitMA kann darum flexibel
    angepasst werden, was als Übereinstimmung gewertet werden soll.
    Um die erstellten Annotationsdaten automatisch in die CATMA-Webapp
    hochladen zu können, erstellen Sie in Ihrem CATMA-Projekt eine neue
    <italic>Annotation Collection</italic>, z.B. mit dem Namen
    „Gold_Annotation“. Kehren Sie zu dieser Lerneinheit zurück, wenn das
    erledigt ist.</p>
  </sec>
  <sec id="catma-projekt-laden-1">
    <title>2. CATMA-Projekt laden</title>
    <p>Wenn Sie Teil 2 dieser Lerneinheit bereits durchgeführt haben,
    wissen Sie schon, dass Sie das CATMA-Projekt, mit dem Sie arbeiten
    wollen, immer zuerst laden müssen. Um das zu tun, nutzen Sie
    untenstehenden Code.</p>
    <code language="python">from gitma import CatmaProject</code>
    <p>Danach können Sie das CATMA-Demo-Projekt laden. Wenn Sie mit
    eigenen Daten arbeiten wollen, so ersetzen Sie in der zweiten
    Code-Zeile „../test/demo_project“ durch den Dateipfad, der zu Ihrem
    CATMA-Projekt führt (Achtung: ​​Sie müssen hier nur den Dateipfad zu
    dem übergeordneten Ordner einfügen, in dem Ihr Projekt liegt. Das
    Projekt selbst hat einen Namen, der diesem ähnelt:
    CATMA_374270D5-006D-498D-BDB4-12D068DEFDC0_Projektname_root. Sie
    müssen hier aber eine Ebene darüber in Ihrem Ordnersystem angeben.).
    Geben Sie außerdem den Projektnamen (nicht den Namen des
    Projektordners) dort ein, wo jetzt „test_corpus“ steht.</p>
    <code language="python">my_project = CatmaProject(  
      project_directory='../test/demo_project/',  
      project_name='test_corpus'  
      )</code>
  </sec>
  <sec id="goldannotationen-automatisch-erstellen">
    <title>3. Goldannotationen automatisch erstellen</title>
    <p>Um die Erstellung von Goldstandard-Annotation zu unterstützen,
    müssen Sie im ersten Schritt zwei Annotationssammlungen vergleichen
    und im zweiten nur diejenigen Annotationen behalten, die
    übereinstimmend annotiert wurden. Im Demo-Projekt dieser Lerneinheit
    gibt es zwei <italic>Annotation Collections</italic>, die „ac_1“ und
    „ac_2“ genannt wurden. Außerdem gibt es die leere <italic>Annotation
    Collection</italic> namens „gold_annotations“. Als Übereinstimmung
    werden hier Annotationen gewertet, die sich zu mindestens 95%
    überlappen. Eine Annotation kann also z.B. etwas länger sein als die
    andere oder einen leicht anderen Start- und/oder Endpunkt haben. Die
    genutzten Annotationskategorien (Tags) müssen die gleichen sein und
    die <italic>Properties</italic> müssen gleich vergeben worden sein.
    Um die Funktion mit den Demo-Daten auszuprobieren, müssen Sie den
    Code nicht anpassen.
    Wenn Sie mit eigenen Daten arbeiten, so müssen Sie die Namen der
    <italic>Annotation Collections</italic> durch diejenigen ersetzen,
    die Sie in Ihrem Projekt verwenden. Achten Sie dabei auf die exakte
    Schreibweise! Sie können bestimmte Tags bei der Erstellung einer
    Goldstandard-Annotation ausschließen. Geben Sie dazu die Namen der
    Tags in die eckigen Klammern hinter „excluded_tags=“ ein. Setzen Sie
    jeden Tagnamen in Anführungsstriche und trennen Sie die einzelnen
    Tags mit Kommas voneinander. Wenn Sie die Definition
    übereinstimmender Annotationen anpassen möchten, geben Sie statt der
    0,95 bei „min_overlap“ einen anderen Wert ein. Möglich sind Werte
    von 0-1, wobei 0 für keinerlei Überlappung steht und darum hier kein
    sinnvoller Wert wäre und 1 für eine 100%-ige Überlappung. Möchten
    Sie auch Annotationen als übereinstimmend werten, bei denen zwar
    dieselbe Textpassage annotiert wurde, nicht aber mit demselben Tag,
    so geben Sie statt „same_tag=True“ „same_tag=False“ ein. Bei
    „property_values“ können Sie statt „matching“ auch „none“ eingeben.
    In diesem Fall werden <italic>Property Values</italic> nicht in die
    Erstellung der Goldstandard-Annotationen einbezogen. Wenn Sie eine
    automatisch erstellte Goldstandard-Annotation über GitLab in Ihr
    CATMA-Projekt hochladen wollen (dies geht nur mit eigenen
    CATMA-Daten), so geben Sie „True“ bei „push_to_gitlab“ ein.</p>
    <code language="python">my_project.create_gold_annotations(  
      ac_1_name='ac_1',  
      ac_2_name='ac_2',  
      gold_ac_name='gold_annotation',  
      excluded_tags=[],  
      min_overlap=0.95,  
      same_tag=True,  
      property_values='matching',  
      push_to_gitlab=False  
      )</code>
    <p><bold><italic>Aufgabe 7</italic></bold>: Wie viele Annotationen
    wurden jeweils in den <italic>Annotation Collections</italic>
    gefunden und wie viele davon stimmen nicht zu 95% überein?</p>
    <p>Wenn Sie mit eigenen Daten arbeiten und die
    Goldstandard-Annotationen automatisch per GitLab in Ihren
    CATMA-Account hochgeladen haben, so müssen Sie Ihr CATMA-Projekt
    noch synchronisieren, damit die Änderungen dort sichtbar werden.
    Loggen Sie sich dazu in Ihren CATMA-Account ein und gehen Sie in Ihr
    Projekt. Klicken Sie rechts auf das Drei-Punkte-Menü und dann auf
    „Synchronize with the team“ (vgl. Abb. 9). Ihre Änderungen werden
    sichtbar sein, sobald der Vorgang abgeschlossen ist.</p>
    <fig>
      <caption><p>Abb. 9: CATMA-Projekt synchronisieren</p></caption>
      <graphic mimetype="image" mime-subtype="png" xlink:href="project_synchronize.PNG" />
    </fig>
    <p>Sie wissen nun, wie Sie einen Goldstandard für übereinstimmende
    Annotationen errechnen und erstellen lassen können und diesen auch
    zurück in Ihr CATMA-Projekt laden. Vielleicht möchten Sie die
    Übereinstimmungen bei der Annotation in Ihrem Projekt aber viel
    genauer analysieren. Dabei helfen Berechnungen des
    Inter-Annotator-Agreements. Wie Sie diese mit CATMA-Daten
    durchführen, lernen Sie im vierten Teil dieser Lerneinheit. Öffnen
    Sie dazu nun das Notebook mit dem Titel „Annotationen auswerten mit
    GitMA 4“.</p>
  </sec>
  <sec id="inter-annotator-agreement-berechnen">
    <title>Inter-Annotator-Agreement berechnen</title>
    <p>Wenn Sie in CATMA mit Ihrem Team kollaborativ annotiert haben, so
    interessiert es Sie vielleicht, wie hoch die Übereinstimmung der
    Annotator*innen miteinander ist. Eine solche Übereinstimmung (auch
    Inter-Annotator-Agreement oder kurz IAA genannt) kann auf
    unterschiedliche Weisen berechnet werden. GitMA bietet insgesamt
    vier Varianten der Berechnung eines IAAs für zwei oder mehr
    Annotator*innen an: <italic>Scott’s pi</italic>, <italic>Cohen’s
    kappa</italic>, <italic>Krippendorf’s alpha</italic>
    (<xref alt="Artstein und Poesio 2008" rid="ref-artsteinInterCoderAgreementComputational2008" ref-type="bibr">Artstein
    und Poesio 2008</xref>) und das <italic>Gamma</italic>-Agreement
    (<xref alt="Mathet, Widlöcher und Métivier 2015" rid="ref-mathetUnifiedHolisticMethod2015" ref-type="bibr">Mathet,
    Widlöcher und Métivier 2015</xref>). Die ersten drei IAA-Varianten
    können mit dem Python Package <italic>Natural Language
    Toolkit</italic>
    (<xref alt="Bird, Klein und Loper 2009" rid="ref-birdNaturalLanguageProcessing2009" ref-type="bibr">Bird,
    Klein und Loper 2009</xref>) berechnet werden, die vierte mit dem
    Package <italic>pygamma-agreement</italic>
    (<xref alt="Titeux und Riad 2021" rid="ref-titeuxPygammaagreementGammaMeasure2021" ref-type="bibr">Titeux
    und Riad 2021</xref>). Bei der Berechnung von Gamma wird mit
    einbezogen, dass die Einheiten, die annotiert werden, von den
    Annotator*innen individuell gewählt werden können. In CATMA kann
    gänzlich individuell annotiert werden, d.h., es können
    Buchstabenkombinationen, Wörter, Phrasen, Satzteile, Sätze, freie
    Passagen oder Absätze usw. annotiert werden und das auch noch auf
    verschiedene Weisen überlappend
    (<xref alt="Horstmann 2024" rid="ref-horstmannLerneinheitManuelleAnnotation2019" ref-type="bibr">Horstmann
    2024</xref>). Darum kann es entscheidend sein, bei der Berechnung
    des IAA das sogenannte <italic>Unitizing</italic>, also die
    Variabilität der Units / Annotationseinheiten, zu berücksichtigen.
    Leider gibt es für die Berechnung des IAA keine Standard-Variante,
    die für alle Arten von Annotationsprojekten empfohlen werden kann
    (<xref alt="Pagel u. a. 2020" rid="ref-pagelAnnotationAlsFlexibel2020" ref-type="bibr">Pagel
    u. a. 2020</xref>). Stattdessen muss individuell entschieden werden,
    welcher Wert genau berechnet werden soll. Wenn Sie die
    Übereinstimmung zwischen Annotator*innen genauer betrachten wollen,
    so öffnen Sie dazu das vierte Jupyter Notebook zu dieser Lerneinheit
    mit dem Namen „Annotationen auswerten mit GitMA 4.ipynb“ und folgen
    Sie den Anleitungen im Notebook.
    Wir empfehlen, jeweils eine <italic>Annotation Collection</italic>
    pro Annotator*in und Dokument anzulegen. Am besten wird jede
    <italic>Annotation Collection</italic> so benannt, dass Titel,
    Annotationsaufgabe und Annotator*in enthalten sind.</p>
    <p><bold>Zum Beispiel:</bold>
    Robinson_Crueso-narrativer_Raum-Mareike</p>
  </sec>
  <sec id="catma-projekt-laden-2">
    <title>1. CATMA-Projekt laden</title>
    <p>Für diese Lerneinheit haben wir ein Beispielprojekt vorbereitet,
    das Annotationen von zwei Annotatoren zu Kafkas
    <italic>Urteil</italic> enthält. Wenn Sie mit eigenen Daten arbeiten
    wollen, so können Sie diese aus Ihrem CATMA-Account herunterladen.
    Wie Sie das tun können, erfahren Sie im ersten Notebook
    („Annotationen auswerten mit GitMA 1“) zu dieser Lerneinheit. Wenn
    Sie das Demo-Projekt nutzen möchten, so können Sie den Code
    unverändert übernehmen.
    Wenn Sie mit eigenen Daten arbeiten möchten, müssen Sie den Code
    leicht anpassen. Schreiben Sie in die einfachen Anführungsstriche
    hinter „project_name“, in denen jetzt „test_corpus“ steht, den Namen
    Ihres CATMA-Projektes. Hinter „project_directory“ müssen Sie den
    Dateipfad angeben, der zu dem Ordner auf Ihrem Computer führt, in
    dem das CATMA-Projekt abgelegt wurde. Ersetzen Sie
    „../test/demo_project/“ durch den Dateipfad, den Sie im ersten
    Notebook dieser Lerneinheit als „backup_directory“ angegeben
    haben.</p>
    <code language="python">from gitma import CatmaProject  

my_project = CatmaProject(  
      project_name='test_corpus',  
      project_directory='../test/demo_project/'  
      )</code>
  </sec>
  <sec id="einführung-in-die-funktion-get_iaa">
    <title>2. Einführung in die Funktion get_iaa()</title>
    <p>Im Demo-Projekt für diese Lerneinheit gibt es einen Text mit
    insgesamt drei <italic>Annotation Collections</italic>. Das
    Inter-Annotator-Agreement wird für zwei dieser <italic>Annotation
    Collections</italic> errechnet (die <italic>Annotation
    Collections</italic> wurden als „ac_1“ und „ac_2“ benannt).
    Mit der Funktion get_iaa() wird für jede Annotation in einer
    <italic>Annotation Collection</italic> die am besten passende
    Annotation in einer zweiten Collection gesucht. Der Vergleich
    basiert auf der annotierten Textpassage, also auf der
    Annotationsspanne. Die folgenden Grafiken verdeutlichen, wie
    Annotationen ausfindig gemacht werden, die zueinander passen (vgl.
    Abb 10).</p>
    <fig>
      <caption><p>Abb. 10: Unterschiedlich gut zueinander passende
      Annotationen</p></caption>
      <graphic mimetype="image" mime-subtype="png" xlink:href="best_match_example_iaa.png" />
    </fig>
    <p>Von allen Annotationen werden bei den IAA-Varianten, die mit
    dieser Funktion berechnet werden können, immer nur die
    berücksichtigt, die am besten passt.</p>
  </sec>
  <sec id="allgemeines-beispiel">
    <title>2.1 Allgemeines Beispiel</title>
    <p>Wenn Sie zunächst einmal die Annotationsspannen in zwei
    <italic>Annotation Collections</italic> vergleichen wollen, so
    können Sie das mithilfe einer Visualisierung tun. Die
    Annotationsspannen werden dabei anhand ihrer Anfangspunkte
    verglichen. Wenn Sie mit dem Demo-Projekt arbeiten, so nutzen Sie
    dazu einfach untenstehenden Code.
    Wenn Sie mit eigenen Daten arbeiten, so ersetzen Sie in der eckigen
    Klammer die Namen der <italic>Annotation Collections</italic> aus
    dem Demo-Projekt durch die aus Ihrem eigenen CATMA-Projekt.</p>
    <code language="python">my_project.compare_annotation_collections(annotation_collections=['ac_1', 'ac_2'])</code>
    <p>Im nächsten Schritt berechnen wir nun die Übereinstimmung für
    alle passenden Annotationen. Klicken Sie dazu in die nächste Box und
    dann oben auf „Run“. Wenn Sie mit eigenen Annotationsdaten arbeiten,
    vergessen Sie nicht, die Namen der <italic>Annotation
    Collections</italic> durch die Ihrer eigenen zu ersetzen.</p>
    <code language="python">my_project.get_iaa(ac1_name='ac_1',ac2_name='ac_2')</code>
    <p><bold><italic>Aufgabe 8</italic></bold>: Wie Sie sehen, gibt
    Ihnen diese Funktion drei Varianten des IAAs aus. Welche
    Informationen erhalten Sie darüber hinaus zur Übereinstimmung der
    Annotationen? Vergleichen Sie die ausgegebene Tabelle mit der
    Visualisierung, die Sie vorhin erstellt haben und den Beispielen für
    passende Annotationen. Für welche drei statischen Events gibt es
    passende Annotationen in der zweiten <italic>Annotation
    Collection</italic> und welchem Beispiel für passende Annotation
    entspricht das?</p>
  </sec>
  <sec id="nach-annotationskategorien-filtern">
    <title>2.2 Nach Annotationskategorien filtern</title>
    <p>Wenn Sie nicht für alle Annotationskategorien in Ihren
    <italic>Annotation Collections</italic> die Übereinstimmung der
    Annotationen berechnen wollen, sondern nur für ausgewählte Tags, so
    können Sie das mit dem folgenden Code tun. Möchten Sie das
    Demo-Projekt nutzen, so können Sie wie gewohnt den Code unverändert
    ausführen.
    Wenn Sie eigene Daten nutzen wollen, tauschen Sie wieder die Namen
    der <italic>Annotation Collections</italic> aus. Ändern Sie dann den
    Namen des Tags in den eckigen Klammern bei „tag_filter“ und tragen
    Sie hier den Namen einer Ihrer eigenen Annotationskategorien ein.
    Wenn Sie weitere Tags berücksichtigen möchten, so ergänzen Sie in
    den eckigen Klammern einfach weitere Namen von Tags aus Ihren
    <italic>Annotation Collections</italic>. Setzen Sie dabei jeden
    Tagnamen in einfache Anführungsstriche und setzen Sie Kommas
    dazwischen.</p>
    <code language="python">my_project.get_iaa(  
      ac1_name='ac_1',  
      ac2_name='ac_2',  
      tag_filter=['process']  
      )</code>
    <p><bold><italic>Aufgabe 9</italic></bold>: In der Abfrage
    berücksichtigen Sie nur eine Annotationskategorie
    (<italic>process</italic>). Wie erklären Sie sich, dass hier
    trotzdem in der Tabelle auch die andere Annotationskategorie
    auftaucht?</p>
    <p>Tipp: Berücksichtigen Sie bei Ihrer Antwort auch die
    Visualisierung und die grafischen Beispiele für passende
    Annotationen!
    Sie können diesen Effekt herausnehmen, indem Sie nicht nur von einer
    <italic>Annotation Collection</italic> als Basis ausgehen, sondern
    den Filter, der nur bestimmte Tags in die Berechnungen einbezieht,
    auf beide <italic>Annotation Collections</italic> ausweiten. Nutzen
    Sie dazu den folgenden Code wie gehabt unverändert, wenn Sie das
    Demo-Projekt nutzen wollen, oder passen Sie ihn wie oben an, wenn
    Sie eigene Daten nutzen.</p>
    <code language="python">my_project.get_iaa(  
      ac1_name='ac_1',  
      ac2_name='ac_2',  
      tag_filter=['process'],  
      filter_both_ac=True  
      )</code>
    <p>Wie Sie sehen, wird nun in der vierten Zeile des Ergebnisses
    angezeigt, dass für eine Annotation keine passende in der zweiten
    <italic>Annotation Collection</italic> gefunden wurde. Trotzdem sind
    die Übereinstimmungswerte dieselben wie in der obigen Berechnung.
    Das liegt daran, dass es in unserem Demo-Projekt nur zwei
    unterschiedliche Tags gibt. Wenn Sie mit eigenen Daten arbeiten,
    können die Ergebnisse ganz anders aussehen.</p>
  </sec>
  <sec id="annotationen-mit-properties-vergleichen">
    <title>2.3 Annotationen mit <italic>Properties</italic>
    vergleichen</title>
    <p>In CATMA können Sie für jede Annotationskategorie eine oder
    mehrere Eigenschaften (<italic>Properties</italic>) angeben, die
    zwei oder mehr Ausprägungen (<italic>Values</italic>) haben können.
    Tags sind also nur eine Ebene von CATMA-Annotationen und natürlich
    können Sie auch <italic>Properties</italic> und
    <italic>Values</italic> in die Berechnung des
    Inter-Annotator-Agreements einbeziehen. In unserem Beispielprojekt
    gibt es die <italic>Property</italic> „mental“, die immer dann
    verwendet wird, wenn ein im Text dargestelltes Ereignis nicht
    tatsächlich (innerhalb der erzählten Welt) stattfindet, sondern nur
    in der Vorstellung einer Figur (mental event). Auch hier erstellen
    wir zunächst wieder eine Visualisierung, um uns die Übereinstimmung
    grafisch vor Augen zu führen. Um dies mit den Demo-Daten zu tun,
    müssen Sie wieder nichts anpassen.
    Wenn Sie eigene Daten nutzen, so ändern Sie wieder wie gehabt die
    Namen der <italic>Annotation Collections</italic> in den eckigen
    Klammern. Damit die Nutzung der <italic>Properties</italic> farblich
    dargestellt wird, geben Sie bei „color_col“ in die einfachen
    Anführungsstriche den Namen der <italic>Property</italic> ein, deren
    Nutzung Sie analysieren wollen.</p>
    <code language="python">my_project.compare_annotation_collections(  
      annotation_collections=['ac_1', 'ac_2'],  
      color_col='prop:mental'  
      )</code>
    <p>Um nun die mathematische Berechnung des Agreements durchzuführen,
    nutzen Sie einen sogenannten „Level“-Parameter. Um die Funktion mit
    den Beispieldaten auszuführen, können Sie einfach wieder den
    unveränderten Code nutzen.
    Möchten Sie die Berechnung mit eigenen Daten durchführen, passen Sie
    auch hier wieder die Namen der <italic>Annotation
    Collections</italic> an. Ersetzen Sie dann noch „mental“ durch den
    Namen einer <italic>Property</italic> aus Ihrer <italic>Annotation
    Collection</italic>.</p>
    <code language="python">my_project.get_iaa(  
      ac1_name='ac_1',  
      ac2_name='ac_2',  
      level='prop:mental'  
      )</code>
    <p>An diesem Beispiel zeigt sich sehr gut, dass diese Art, die
    Übereinstimmung zu berechnen, Uneinigkeiten außer Acht lässt, sofern
    diese nicht die am besten zueinander passenden Annotationen
    betreffen. Bei der letzten Annotation aus der ersten
    <italic>Annotation Collection</italic> wird die
    nicht-übereinstimmende Annotation aus der zweiten Collection nicht
    berücksichtigt, weil es sich dabei nicht um die am besten zu der
    Annotation aus „ac_1“ passende Annotation handelt. Wenn also
    unterschiedliche Annotationsspannen eine große Rolle spielen, so
    empfehlen wir die Berechnung des Gamma-Agreements.</p>
  </sec>
  <sec id="das-gamma-agreement-berechnen">
    <title>3. Das Gamma-Agreement berechnen</title>
    <p>Um das Gamma-Agreement zu berechnen, müssen Sie zusätzlich zu den
    <italic>Annotation Collections</italic> noch 5 weitere Parameter
    definieren:</p>
    <list list-type="bullet">
      <list-item>
        <p><italic>alpha</italic>: Koeffizient zur Gewichtung der
        Unähnlichkeit von Annotationen im Hinblick auf deren Position
        (default-Wert ist 1)</p>
      </list-item>
      <list-item>
        <p><italic>beta</italic>: Koeffizient zur Gewichtung der
        Unähnlichkeit von Annotationen im Hinblick auf deren
        Annotationskategorie (default-Wert ist 1)</p>
      </list-item>
      <list-item>
        <p><italic>delta_empty</italic>: Bewertung der Unähnlichkeit im
        Hinblick auf Leerstellen, d.h., wenn eine Textpassage von einem
        Annotator / einer Annotatorin annotiert wurde und vom / von der
        anderen nicht (default-Wert ist 1)</p>
      </list-item>
      <list-item>
        <p><italic>n_samples</italic>: Anzahl der zufällig gewählten
        Annotationsspannenverteilungen, die genutzt werden, um einen
        erwarteten Gamma-Wert zu berechnen (im Beispiel wird die
        tatsächliche Verteilung der Annotationsspannen mit 30 Samples
        zufälliger Annotationsspannenverteilung verglichen.)</p>
      </list-item>
      <list-item>
        <p><italic>akzeptierte Fehleranfälligkeit</italic> bei der
        Berechnung des erwarteten Gamma-Wertes (kann als „high“=1%,
        „medium“=2% oder „low“=5% spezifiziert werden)</p>
      </list-item>
    </list>
    <p>Weitere Erklärungen zur Berechnung des Gamma-Agreements finden
    Sie in der Dokumentation von <italic>pygamma</italic> und bei
    Mathet, Widlöcher und Métivier
    (<xref alt="2015" rid="ref-mathetUnifiedHolisticMethod2015" ref-type="bibr">2015</xref>).
    Auch hier können Sie wieder unsere Demo-Daten für die Berechnung
    nutzen. Dafür müssen Sie den Code unverändert ausführen. Wenn Sie
    mit eigenen Daten arbeiten, passen Sie auch hier wieder die Namen
    der <italic>Annotation Collections</italic> so an, dass Sie denen
    entsprechen, die Sie in die Berechnung einbeziehen wollen.</p>
    <code language="python">my_project.gamma_agreement(  
      annotation_collections=['ac_1', 'ac_2'],  
      alpha=1,  
      beta=1,  
      delta_empty=1,  
      n_samples=30,  
      precision_level=0.01  
      )</code>
    <p>Wenn Sie mit weiteren, hier nicht aufgeführten Varianten das
    Inter-Annotator-Agreement direkt mit dem <italic>pygamma</italic>
    Package berechnen wollen, so können Sie dafür Rohdaten aus Ihrem
    CATMA-Projekt generieren. Mit dem unten stehenden Code können Sie
    diese als CSV-Tabelle speichern.
    Nutzen Sie auch hier unser Demo-Projekt, indem Sie den nächsten Code
    unverändert ausführen. Passen Sie Folgendes an, um mit eigenen Daten
    zu arbeiten: Die Namen der <italic>Annotation Collections</italic>
    (wie gehabt) und den Dateipfad, unter dem die Tabelle gespeichert
    werden soll. Ändern Sie dazu die Angabe „../test/pygamma_table.csv“
    so ab, dass hier der Pfad steht, unter dem Ihre Version der Tabelle
    in der Ordnerstruktur Ihres Rechners abgelegt werden soll.</p>
    <code language="python">pygamma_df = my_project.pygamma_table(  
      annotation_collections=['ac_1', 'ac_2']  
      )  
      pygamma_df.to_csv('../test/pygamma_table.csv', index=False, header=False)  
      pygamma_df.head(5)</code>
  </sec>
</sec>
<sec id="lösungen-zu-den-beispielaufgaben">
  <title>4. Lösungen zu den Beispielaufgaben</title>
  <p><bold><italic>Aufgabe 1</italic></bold>: In welcher Spalte der
  Tabelle finden Sie Ihre Tagsets?</p>
  <p>In der vierten Spalte der Tabelle finden Sie Ihre Tags. Die
  einzelnen Tags sind in geschweiften Klammern dargestellt, sodass sie
  zu Ihren Tagsets zusammengefasst sind.</p>
  <p><bold><italic>Aufgabe 2</italic></bold>: Vergleichen Sie die beiden
  Visualisierungen. Welche Textstelle wurde in einer <italic>Annotation
  Collection</italic> als <italic>Stative Event</italic> und in der
  anderen als <italic>Process</italic> annotiert?</p>
  <p>Die Textstelle „Er hatte gerade einen Brief an einen sich im
  Ausland befindenden Jugendfreund gesendet“ wurde in der
  <italic>Annotation Collection</italic> mit der ID 1 als
  <italic>Process</italic> annotiert, in der <italic>Annotation
  Collection</italic> mit der ID 3 als <italic>Stative
  Event</italic>.</p>
  <p><bold><italic>Aufgabe 3</italic></bold>: Wie viele Annotationen
  weisen die <italic>Property</italic> „intentional“ nicht auf?</p>
  <p>Vier Annotationen werden mit „nan“ angezeigt, was für „Not a
  number“ steht und in diesem Fall bedeutet, dass die
  <italic>Property</italic> nicht vergeben wurde, also auch keinen Wert
  hat.</p>
  <p><bold><italic>Aufgabe 4</italic></bold>: Aus der Tabelle unter „2.
  Generelle Statistiken aufrufen“ können Sie ablesen, dass beide
  Annotatoren jeweils sechs Annotationen gemacht haben. Wie erklären Sie
  sich, dass hier nur insgesamt acht Annotationen angezeigt werden?</p>
  <p>Die Annotationen der Annotator*innen können auf denselben
  Textstellen liegen. In diesem Fall werden die Annotationen der ersten
  <italic>Annotation Collection</italic> angezeigt. Nur abweichende
  Annotationen bekommen einen eigenen Punkt in der Visualisierung und
  werden auch farblich entsprechend dargestellt.</p>
  <p><bold><italic>Aufgabe 5</italic></bold>: Statische oder
  Prozess-Events: Mit welcher Annotationskategorie wurde die längste
  Textpassage annotiert und wie viele Zeichen umfasst diese?</p>
  <p>Mit der Annotationskategorie „Stative Event“ wurde eine Passage von
  insgesamt 233 Zeichen annotiert. Dies ist die längste annotierte
  Passage im Korpus des Demo-Projektes.</p>
  <p><bold><italic>Aufgabe 6</italic></bold>: Wie viele
  <italic>Events</italic> wurden als <italic>intentional</italic>
  klassifiziert, wie viele als <italic>nicht-intentional</italic> und
  bei wie vielen Annotationen wurde diese <italic>Property</italic>
  nicht mit einem Wert versehen?</p>
  <p>Von den insgesamt sechs Annotationen wurde eine mit der
  <italic>Property</italic> „intentional“ und dem Wert/Value „yes“
  versehen, eine weitere mit „intentional“ und „no“. Bei vier
  Annotationen wurde die <italic>Property</italic> „intentional“ nicht
  vergeben.</p>
  <p><bold><italic>Aufgabe 7</italic></bold>: Wie viele Annotationen
  wurden jeweils in den <italic>Annotation Collections</italic> gefunden
  und wie viele davon stimmen nicht zu 95% überein?</p>
  <p>In jeder <italic>Annotation Collection</italic> wurden sechs
  Annotationen gefunden. Zwei davon stimmen zu mindestens 95% überein.
  Insgesamt acht Annotationen stimmen zu weniger als 95% überein.</p>
  <p><bold><italic>Aufgabe 8</italic></bold>: Wie Sie sehen, gibt Ihnen
  diese Funktion drei Varianten des IAAs aus. Welche Informationen
  erhalten Sie darüber hinaus zur Übereinstimmung der Annotationen?
  Vergleichen Sie die ausgegebene Tabelle mit der Visualisierung, die
  Sie vorhin erstellt haben und den Beispielen für passende
  Annotationen. Für welche drei statischen Events gibt es passende
  Annotationen in der zweiten <italic>Annotation Collection</italic> und
  welchem Beispiel für passende Annotationen entspricht das?</p>
  <p>Es wird angezeigt, wie viele zusammenpassende Annotationen in den
  <italic>Annotation Collections</italic> gefunden wurden (im
  Demo-Projekt 6). Außerdem erfährt man noch, wie hoch die
  durchschnittliche Überlappung ist (im Demo-Projekt rund 83%) und wie
  viele Annotationen es gibt, für die keine passende Entsprechung in der
  anderen <italic>Annotation Collection</italic> gefunden wurde (im
  Demo-Projekt 0). Für die ersten drei Annotationen statischer Events in
  der Annotation Collection „ac_1“ gibt es passende Annotationen in
  „ac_2“. Es handelt sich dabei um die ersten beiden Annotationen aus
  dieser zweiten <italic>Annotation Collection</italic>. Die ersten
  beiden Annotationen umfassen eine ähnliche Textspanne, wie in Beispiel
  4 gezeigt. Die zweite und dritte Annotation der zweiten
  <italic>Annotation Collection</italic> fallen in die Spanne der
  zweiten Annotation in der zweiten <italic>Annotation
  Collection</italic>. Dies entspricht Beispiel 5 für passende
  Annotationen.</p>
  <p><bold><italic>Aufgabe 9</italic></bold>: In der Abfrage
  berücksichtigen Sie nur eine Annotationskategorie
  (<italic>process</italic>). Wie erklären Sie sich, dass hier trotzdem
  in der Tabelle auch die andere Annotationskategorie auftaucht? Tipp:
  Berücksichtigen Sie bei Ihrer Antwort auch die Visualisierung und die
  grafischen Beispiele für passende Annotationen!</p>
  <p>Die Berechnung geht immer von einer <italic>Annotation
  Collection</italic> (im Beispielprojekt „ac_1“) aus und basiert auf
  Annotationsspannen. Für die in dieser Collection mit „process“
  annotierten Textpassagen gibt es in der zweiten <italic>Annotation
  Collection</italic> eine 100%-ige Überlappung im Sinne von Beispiel 3
  für die letzte und vorletzte Textpassage. Für die erste Textspanne,
  die mit „process“ annotiert wurde, gibt es in der zweiten
  <italic>Annotation Collection</italic> ebenfalls eine 100%-ige
  Überlappung, nur dass die Passage hier mit „stative_event“ annotiert
  wurde.</p>
</sec>
<sec id="externe-und-weiterführende-links">
  <title>Externe und weiterführende Links</title>
  <list list-type="bullet">
    <list-item>
      <p>Anaconda:
      <ext-link ext-link-type="uri" xlink:href="https://web.archive.org/save/https://www.anaconda.com/products/individual">https://web.archive.org/save/https://www.anaconda.com/products/individual</ext-link>
      (Letzter Zugriff: 03.07.2024)</p>
    </list-item>
    <list-item>
      <p>CATMA GitLab:
      <ext-link ext-link-type="uri" xlink:href="https://web.archive.org/save/https://git.catma.de/">https://web.archive.org/save/https://git.catma.de/</ext-link>
      (Letzter Zugriff: 03.07.2024)</p>
    </list-item>
    <list-item>
      <p>forTEXT.net GitHub-Repository:
      <ext-link ext-link-type="uri" xlink:href="https://web.archive.org/save/hhttps://github.com/forTEXT/forTEXT.net">https://web.archive.org/save/hhttps://github.com/forTEXT/forTEXT.net</ext-link>
      (Letzter Zugriff: 03.07.2024)</p>
    </list-item>
    <list-item>
      <p>GitMA GitHub-Repository:
      <ext-link ext-link-type="uri" xlink:href="https://web.archive.org/save/https://github.com/forTEXT/gitma">https://web.archive.org/save/https://github.com/forTEXT/gitma</ext-link>
      (Letzter Zugriff: 03.07.2024)</p>
    </list-item>
    <list-item>
      <p>Pandas Dokumentation:
      <ext-link ext-link-type="uri" xlink:href="https://web.archive.org/save/https://pandas.pydata.org/docs/index.html">https://web.archive.org/save/https://pandas.pydata.org/docs/index.html</ext-link>
      (Letzter Zugriff: 03.07.2024)</p>
    </list-item>
  </list>
</sec>
<sec id="glossar">
  <title>Glossar</title>
  <def-list>
    <def-item>
      <term><styled-content id="glossary-annotation">Annotation</styled-content></term>
      <def>
        <p>Annotation beschreibt die manuelle oder automatische
        Hinzufügung von Zusatzinformationen zu einem Text. Die manuelle
        Annotation wird händisch durchgeführt, während die
        (teil-)automatisierte Annotation durch
        <xref alt="Machine-Learning-Verfahren" rid="glossary-machine-learning">Machine-Learning-Verfahren</xref>
        durchgeführt wird. Ein klassisches Beispiel ist das
        automatisierte
        <xref alt="PoS-Tagging" rid="glossary-pos">PoS-Tagging</xref>
        (Part-of-Speech-Tagging), welches oftmals als Grundlage
        (<xref alt="Preprocessing" rid="glossary-preprocessing">Preprocessing</xref>)
        für weitere Analysen wie Named Entity Recognition (NER) nötig
        ist. Annotationen können zudem deskriptiv oder analytisch
        sein.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-api">API</styled-content></term>
      <def>
        <p>API steht für <italic>Application Programming
        Interface</italic> und bezeichnet eine Programmierschnittstelle,
        die Soft- und Hardwarekomponenten wie Anwendungen, Festplatten
        oder Benutzeroberflächen verbindet. Sie vereinheitlicht die
        Datenübergabe zwischen Programmteilen, etwa Modulen, und
        Programmen.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-browser">Browser</styled-content></term>
      <def>
        <p>Mit Browser ist in der Regel ein Webbrowser gemeint, also ein
        Computerprogramm, mit dem das Anschauen, Navigieren auf, und
        Interagieren mit Webseiten möglich wird. Am häufigsten genutzt
        werden dafür Chrome, Firefox, Safari oder der Internet
        Explorer.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-commandline">Commandline</styled-content></term>
      <def>
        <p>Die Commandline (engl. <italic>command line
        interface</italic> (CLI)), auch Kommandozeile, Konsole, Terminal
        oder Eingabeaufforderung genannt, ist die direkteste Methode zur
        Interaktion eines Menschen mit einem Computer. Programme ohne
        eine grafische Benutzeroberfläche
        (<xref alt="GUI" rid="glossary-gui">GUI</xref>) werden i. d. R.
        durch Texteingabe in die Commandline gesteuert. Um die
        Commandline zu öffnen, klicken Sie auf Ihrem Mac „cmd“ +
        „space“, geben „Terminal“ ein und doppelklicken auf das
        Suchergebnis. Bei Windows klicken Sie die Windowstaste + „R“,
        geben „cmd.exe“ ein und klicken Enter.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-csv">CSV</styled-content></term>
      <def>
        <p>CSV ist die englische Abkürzung für <italic>Comma Separated
        Values</italic>. Es handelt sich um ein Dateiformat zur
        einheitlichen Darstellung und Speicherung von einfach
        strukturierten Daten mit dem Kürzel <monospace>.csv</monospace>
        , sodass diese problemlos zwischen IT-Systemen ausgetauscht
        werden können. Dabei sind alle Daten zeilenweise angeordnet.
        Alle Zeilen wiederum sind in einzelne Datenfelder aufgeteilt,
        welche durch Trennzeichen wie Semikola oder Kommata getrennt
        werden können. In Programmen wie Excel können solche Textdateien
        als Tabelle angezeigt werden.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-feature">Feature</styled-content></term>
      <def>
        <p>Unter Features können Einzelfunktionen eines Tools verstanden
        werden, die beispielsweise komplexe Funktionen wie die
        Visualisierung eines Textes als
        <xref alt="Wordcloud" rid="glossary-wordcloud">Wordcloud</xref>
        ermöglichen, oder auch kleinere Funktionseinheiten wie den
        Abgleich einzelner Spracheigenschaften
        (<xref alt="Properties" rid="glossary-property">Properties</xref>)
        mit
        <xref alt="annotierten" rid="glossary-annotation">annotierten</xref>
        Beispieltexten darstellen.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-gui">GUI</styled-content></term>
      <def>
        <p>GUI steht für <italic>Graphical User Interface</italic> und
        bezeichnet eine grafische Benutzeroberfläche. Ein GUI ermöglicht
        es, Tools mithilfe von grafischen Schaltflächen zu bedienen, um
        somit beispielsweise den Umgang mit der
        <xref alt="Commandline" rid="glossary-commandline">Commandline</xref>
        zu umgehen.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-json">JSON</styled-content></term>
      <def>
        <p>JSON ist die englische Abkürzung für <italic>JavaScript
        Object Notation</italic> . Dabei handelt es sich um ein
        kompaktes Textformat, das insbesondere zum Datenaustausch
        entworfen wurde. Es ist für Menschen einfach zu lesen und zu
        schreiben und für Maschinen einfach zu analysieren und zu
        generieren. JSON ist ein Format, das unabhängig von
        Programmiersprachen ist.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-lemmatisieren">Lemmatisieren</styled-content></term>
      <def>
        <p>Die Lemmatisierung von Textdaten gehört zu den wichtigen
        <xref alt="Preprocessing" rid="glossary-preprocessing">Preprocessing</xref>-Schritten
        in der Textverarbeitung. Dabei werden alle Wörter
        (<xref alt="Token" rid="glossary-type-token">Token</xref>) eines
        Textes auf ihre Grundform zurückgeführt. So werden
        beispielsweise Flexionsformen wie „schneller“ und „schnelle“ dem
        Lemma „schnell“ zugeordnet.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-machine-learning">Machine
      Learning</styled-content></term>
      <def>
        <p>Machine Learning, bzw. maschinelles Lernen im Deutschen, ist
        ein Teilbereich der künstlichen Intelligenz. Auf Grundlage
        möglichst vieler (Text-)Daten erkennt und erlernt ein Computer
        die häufig sehr komplexen Muster und Gesetzmäßigkeiten
        bestimmter Phänomene. Daraufhin können die aus den Daten
        gewonnen Erkenntnisse verallgemeinert werden und für neue
        Problemlösungen oder für die Analyse von bisher unbekannten
        Daten verwendet werden.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-named-entities">Named
      Entities</styled-content></term>
      <def>
        <p>Eine Named Entity (NE) ist eine Entität, oft ein Eigenname,
        die meist in Form einer Nominalphrase zu identifizieren ist.
        Named Entities können beispielsweise Personen wie „Nils
        Holgerson“, Organisationen wie „WHO“ oder Orte wie „New York“
        sein. Named Entities können durch das Verfahren der Named Entity
        Recognition (NER) automatisiert ermittelt werden.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-pos">POS</styled-content></term>
      <def>
        <p>PoS steht für <italic>Part of Speech</italic> , oder
        „Wortart“ auf Deutsch. Das PoS-
        <xref alt="Tagging" rid="glossary-annotation">Tagging</xref>
        beschreibt die (automatische) Erfassung und Kennzeichnung von
        Wortarten in einem Text und ist of ein wichtiger
        <xref alt="Preprocessing" rid="glossary-preprocessing">Preprocessing</xref>-Schritt,
        beispielsweise für die Analyse von
        <xref alt="Named Entities" rid="glossary-named-entities">Named
        Entities</xref>.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-preprocessing">Preprocessing</styled-content></term>
      <def>
        <p>Für viele digitale Methoden müssen die zu analysierenden
        Texte vorab „bereinigt“ oder „vorbereitet“ werden. Für
        statistische Zwecke werden Texte bspw. häufig in gleich große
        Segmente unterteilt (<italic>chunking</italic>), Großbuchstaben
        werden in Kleinbuchstaben verwandelt oder Wörter werden
        <xref alt="lemmatisiert" rid="glossary-lemmatisieren">lemmatisiert</xref>.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-code">Programmiercode</styled-content></term>
      <def>
        <p>Der Code, oder auch Programmcode/ Maschinencode, bezieht sich
        auf eine Sammlung von Anweisungen, die durch verschiedene
        Programmiersprachen wie Java, Python oder C realisiert werden
        können. Für die Ausführung der Anweisungen wird der Code durch
        einen Compiler oder einen Interpreter in die Maschinensprache,
        einen Binärcode, des Computers übersetzt.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-property">Property</styled-content></term>
      <def>
        <p>Property steht für „Eigenschaft“, „Komponente“ oder
        „Attribut“. In der automatischen
        <xref alt="Annotation" rid="glossary-annotation">Annotation</xref>
        dienen konkrete Worteigenschaften wie Groß- und Kleinschreibung
        zur Klassifizierung von Wörtern oder Phrasen. Durch die
        Berücksichtigung solcher Eigenschaften in den
        <xref alt="Features" rid="glossary-feature">Features</xref>
        eines Tools kann
        <xref alt="maschinelles Lernen" rid="glossary-machine-learning">maschinelles
        Lernen</xref> bestimmter Phänomene umgesetzt werden. In der
        manuellen Annotation können als Properties auch Eigenschaften
        von
        <xref alt="Annotationen" rid="glossary-annotation">Annotationen</xref>
        benannt werden.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-stoppwortliste">Stoppwortliste</styled-content></term>
      <def>
        <p>Stoppwörter sind hochfrequente Wörter, meist Funktionswörter,
        die, aufgrund ihrer grammatisch bedingten Häufigkeit,
        beispielsweise die Ergebnisse von inhaltlichen oder thematischen
        Analysen verzerren können. Deshalb werden diese Wörter,
        gesammelt in einer Stoppwortliste, bei digitalen Textanalysen
        meist nicht berücksichtigt.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-tagset">Tagset</styled-content></term>
      <def>
        <p>Ein Tagset definiert die Taxonomie, anhand derer
        <xref alt="Annotationen" rid="glossary-annotation">Annotationen</xref>
        in einem Projekt erstellt werden. Ein Tagset beinhaltet immer
        mehrere Tags und ggf. auch Subtags. Ähnlich der
        <xref alt="Type/Token" rid="glossary-type-token">Type/Token</xref>
        -Differenz in der Linguistik sind Tags deskriptive Kategorien,
        wohingegen Annotationen die einzelnen Vorkommnisse dieser
        Kategorien im Text sind.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-type-token">Type/Token</styled-content></term>
      <def>
        <p>Das Begriffspaar „Type/Token“ wird grundsätzlich zur
        Unterscheidung von einzelnen Vorkommnissen (Token) und Typen
        (Types) von Wörtern oder Äußerungen in Texten genutzt. Ein Token
        ist also ein konkretes Exemplar eines bestimmten Typs, während
        ein Typ eine im Prinzip unbegrenzte Menge von Exemplaren (Token)
        umfasst.
        Es gibt allerdings etwas divergierende Definitionen zur
        Type-Token-Unterscheidung. Eine präzise Definition ist daher
        immer erstrebenswert. Der Satz „Ein Bär ist ein Bär.“ beinhaltet
        beispielsweise fünf Worttoken („Ein“, „Bär“, „ist“, „ein“,
        „Bär“) und drei Types, nämlich: „ein“, „Bär“, „ist“. Allerdings
        könnten auch vier Types, „Ein“, „ein“, „Bär“ und „ist“, als
        solche identifiziert werden, wenn Großbuchstaben beachtet
        werden.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-wordcloud">Wordcloud</styled-content></term>
      <def>
        <p>Eine <italic>Wordcloud</italic> , oder auch Schlagwortwolke,
        ist eine Form der Informationsvisualisierung, beispielsweise von
        Worthäufigkeiten in einem Text oder einer Textsammlung. Dabei
        werden unterschiedlich gewichtete Wörter, wie die häufigsten
        Wörter, i.d.R. größer oder auf andere Weise hervorgehoben
        dargestellt. Die horizontale/vertikale Ausrichtung und die Farbe
        der dargestellten Wörter hat meistens allerdings keinen
        semantischen Mehrwert.</p>
      </def>
    </def-item>
    <def-item>
      <term><styled-content id="glossary-zip">ZIP</styled-content></term>
      <def>
        <p>ZIP steht für ein Dateiformat (zip = engl. Reißverschluss),
        in welchem mehrere Einzeldateien verlustfrei, komprimiert
        zusammengefasst werden. ZIP-Dateien werden beim Öffnen entweder
        automatisch entpackt oder lassen sich per Rechtsklick
        extrahieren.</p>
      </def>
    </def-item>
  </def-list>
</sec>
</body>
<back>
<ref-list>
  <title>Bibliographie</title>
  <ref id="ref-anacondasoftwaredistributionAnacondaDocumentation2020">
    <mixed-citation>Anaconda Software Distribution. 2020. Anaconda
    Documentation.
    <ext-link ext-link-type="uri" xlink:href="https://docs.anaconda.com">https://docs.anaconda.com</ext-link>.</mixed-citation>
  </ref>
  <ref id="ref-artsteinInterCoderAgreementComputational2008">
    <mixed-citation>Artstein, Ron und Massimo Poesio. 2008. Inter-Coder
    Agreement for Computational Linguistics. <italic>Computational
    Linguistics</italic> 34, Nr. 4. doi:
    <ext-link ext-link-type="uri" xlink:href="https://www.mitpressjournals.org/doi/pdfplus/10.1162/coli.07-034-R2">https://www.mitpressjournals.org/doi/pdfplus/10.1162/coli.07-034-R2</ext-link>,.</mixed-citation>
  </ref>
  <ref id="ref-birdNaturalLanguageProcessing2009">
    <mixed-citation>Bird, Steven, Ewan Klein und Edward Loper. 2009.
    <italic>Natural language processing with Python: analyzing text with
    the natural language toolkit</italic>. O’Reilly
    Media.</mixed-citation>
  </ref>
  <ref id="ref-chaconProGit2014">
    <mixed-citation>Chacon, Scott und Ben Straub. 2014. <italic>Pro
    Git</italic>. Apress.</mixed-citation>
  </ref>
  <ref id="ref-giusCATMA2020">
    <mixed-citation>Gius, Evelyn, Jan Christoph Meister, Malte Meister,
    Marco Petris, Christian Bruck, Janina Jacke, Mareike Schumacher,
    Marie Flüh und Jan Horstmann. 2020. CATMA. 11. November.
    <ext-link ext-link-type="uri" xlink:href="https://zenodo.org/records/4353618">https://zenodo.org/records/4353618</ext-link>
    (zugegriffen: 29. April 2022).</mixed-citation>
  </ref>
  <ref id="ref-horstmannLerneinheitManuelleAnnotation2019">
    <mixed-citation>Horstmann, Jan. 2024. Lerneinheit: Manuelle
    Annotation mit CATMA. Hg. von Evelyn Gius. <italic>forTEXT</italic>
    1, Nr. 4. Manuelle Annotation (7. August). doi:
    <ext-link ext-link-type="uri" xlink:href="https://doi.org/10.48694/fortext.3750">10.48694/fortext.3750</ext-link>,
    <ext-link ext-link-type="uri" xlink:href="https://fortext.net/routinen/lerneinheiten/manuelle-annotation-mit-catma">https://fortext.net/routinen/lerneinheiten/manuelle-annotation-mit-catma</ext-link>.</mixed-citation>
  </ref>
  <ref id="ref-horstmannMethodenbeitragTextvisualisierung2018">
    <mixed-citation>Horstmann, Jan und Jan-Erik Stange. 2024.
    Methodenbeitrag: Textvisualisierung. Hg. von Evelyn Gius.
    <italic>forTEXT</italic> 1, Nr. 5. Textvisualisierung (7. August).
    doi:
    <ext-link ext-link-type="uri" xlink:href="https://doi.org/10.48694/fortext.3772">10.48694/fortext.3772</ext-link>,
    <ext-link ext-link-type="uri" xlink:href="https://fortext.net/routinen/methoden/textvisualisierung">https://fortext.net/routinen/methoden/textvisualisierung</ext-link>.</mixed-citation>
  </ref>
  <ref id="ref-jackeMethodenbeitragKollaborativesLiteraturwissenschaftliches2018">
    <mixed-citation>Jacke, Janina. 2024a. Methodenbeitrag:
    Kollaboratives literaturwissenschaftliches Annotieren. Hg. von
    Evelyn Gius. <italic>forTEXT</italic> 1, Nr. 4. Manuelle Annotation
    (7. August). doi:
    <ext-link ext-link-type="uri" xlink:href="https://doi.org/10.48694/fortext.3749">10.48694/fortext.3749</ext-link>,
    <ext-link ext-link-type="uri" xlink:href="https://fortext.net/routinen/methoden/kollaboratives-literaturwissenschaftliches-annotieren">https://fortext.net/routinen/methoden/kollaboratives-literaturwissenschaftliches-annotieren</ext-link>.</mixed-citation>
  </ref>
  <ref id="ref-jackeMethodenbeitragManuelleAnnotation2018">
    <mixed-citation>———. 2024b. Methodenbeitrag: Manuelle Annotation.
    Hg. von Evelyn Gius. <italic>forTEXT</italic> 1, Nr. 4. Manuelle
    Annotation (7. August). doi:
    <ext-link ext-link-type="uri" xlink:href="https://doi.org/10.48694/fortext.3748">10.48694/fortext.3748</ext-link>,
    <ext-link ext-link-type="uri" xlink:href="https://fortext.net/routinen/methoden/manuelle-annotation">https://fortext.net/routinen/methoden/manuelle-annotation</ext-link>.</mixed-citation>
  </ref>
  <ref id="ref-kluyverJupyterNotebooksPublishing2016">
    <mixed-citation>Kluyver, Thomas, Benjamin Ragan-Kelley, Fernando
    Pérez, Brian Granger, Matthias Bussonnier, Jonathan Frederic, Kyle
    Kelley, u. a. 2016. Jupyter Notebooks – a publishing format for
    reproducible computational workflows. In: <italic>Positioning and
    Power in Academic Publishing: Players, Agents and Agendas</italic>,
    hg. von F. Loizides und B. Schmidt, 87–90. IOS
    Press.</mixed-citation>
  </ref>
  <ref id="ref-mathetUnifiedHolisticMethod2015">
    <mixed-citation>Mathet, Yann, Antoine Widlöcher und Jean-Philippe
    Métivier. 2015. The Unified and Holistic Method Gamma (γ) for
    Inter-Annotator Agreement Measure and Alignment.
    <italic>Computational Linguistics</italic> 41, Nr. 3 (1. September):
    437–479. doi:
    <ext-link ext-link-type="uri" xlink:href="https://doi.org/10.1162/COLI_a_00227">10.1162/COLI_a_00227</ext-link>,
    <ext-link ext-link-type="uri" xlink:href="https://doi.org/10.1162/COLI_a_00227">https://doi.org/10.1162/COLI_a_00227</ext-link>
    (zugegriffen: 11. Mai 2023).</mixed-citation>
  </ref>
  <ref id="ref-mckinneyDataStructuresStatistical2010">
    <mixed-citation>McKinney, Wes u. a. 2010. Data structures for
    statistical computing in python. In: <italic>Proceedings of the 9th
    Python in Science Conference</italic>, 445:51–56. Austin,
    TX.</mixed-citation>
  </ref>
  <ref id="ref-pagelAnnotationAlsFlexibel2020">
    <mixed-citation>Pagel, Janis, Nils Reiter, Ina Rösiger und Sarah
    Schulz. 2020. Annotation als flexibel einsetzbare Methode. In:
    <italic>Interdisziplinäre(s) arbeiten in der
    CRETA-Werkstatt</italic>, hg. von Nils Reiter, Axel Pichler, und
    Jonas Kuhn, 125–142. Berlin, Boston: De Gruyter.
    <ext-link ext-link-type="uri" xlink:href="https://doi.org/10.1515/9783110693973-006">https://doi.org/10.1515/9783110693973-006</ext-link>
    (zugegriffen: 19. Oktober 2023).</mixed-citation>
  </ref>
  <ref id="ref-schumacherToolbeitragCATMA2019">
    <mixed-citation>Schumacher, Mareike. 2024a. Toolbeitrag: CATMA. Hg.
    von Evelyn Gius. <italic>forTEXT</italic> 1, Nr. 4. Manuelle
    Annotation (7. August). doi:
    <ext-link ext-link-type="uri" xlink:href="https://doi.org/10.48694/fortext.3761">10.48694/fortext.3761</ext-link>,
    <ext-link ext-link-type="uri" xlink:href="https://fortext.net/tools/tools/catma">https://fortext.net/tools/tools/catma</ext-link>.</mixed-citation>
  </ref>
  <ref id="ref-schumacherMethodenbeitragNetzwerkanalyse2018">
    <mixed-citation>———. 2024b. Methodenbeitrag: Netzwerkanalyse. Hg.
    von Evelyn Gius. <italic>forTEXT</italic> 1, Nr. 6. Netzwerkanalyse
    (30. August). doi:
    <ext-link ext-link-type="uri" xlink:href="https://doi.org/10.48694/fortext.3759">10.48694/fortext.3759</ext-link>,
    <ext-link ext-link-type="uri" xlink:href="https://fortext.net/routinen/methoden/netzwerkanalyse">https://fortext.net/routinen/methoden/netzwerkanalyse</ext-link>.</mixed-citation>
  </ref>
  <ref id="ref-titeuxPygammaagreementGammaMeasure2021">
    <mixed-citation>Titeux, Hadrien und Rachid Riad. 2021.
    pygamma-agreement: Gamma γ measure for inter/intra-annotator
    agreement in Python. <italic>Journal of Open Source
    Software</italic> 6, Nr. 62: 2989. doi:
    <ext-link ext-link-type="uri" xlink:href="https://doi.org/10.21105/joss.02989">10.21105/joss.02989</ext-link>,
    <ext-link ext-link-type="uri" xlink:href="https://doi.org/10.21105/joss.02989">https://doi.org/10.21105/joss.02989</ext-link>.</mixed-citation>
  </ref>
  <ref id="ref-vauthGitMA2022">
    <mixed-citation>Vauth, Michael, Malte Meister, Hans Ole Hatzel,
    Dominik Gerstorfer und Evelyn Gius. 2022. GitMA. Zenodo, 5. März.
    doi:
    <ext-link ext-link-type="uri" xlink:href="https://doi.org/10.5281/ZENODO.6330464">10.5281/ZENODO.6330464</ext-link>,
    <ext-link ext-link-type="uri" xlink:href="https://doi.org/10.5281/ZENODO.6330464">https://doi.org/10.5281/ZENODO.6330464</ext-link>
    (zugegriffen: 20. April 2022).</mixed-citation>
  </ref>
</ref-list>
</back>
</article>
