Meine eigene KI Tagebuch

[danny]

Ich aktualisiere das Projekt mal eben, das es auch passt.

Nach viel hin und hier, veröffentliche ich im Moment, bevor das trainingsmodel und das KI Modell an der reihe ist, die Vor-verarbeitungsabläufe.

Es hat einen einfachen Grund.

Die Daten müssen, in bestimmten Schritten vorverarbeitet werden, bevor man ein Gewünschtes KI Model mit den Datensätzen Trainiert.
Im Moment, besteht der Ablauf der vor-verarbeitung noch aus 3 python codes.
Ziel ist es, gewissen Schritte, ggf in einem code zu implementieren. Aber vorangig ist jetzt erst einmal, die abläufe der 3 Schritte so zu optimieren, das es je nach system auch Große Datensätze in vorm von mehreren GB auch auf etwas schwächerer Hardware verarbeitet werden können.

Das Problem ist, das ca. 100 mb an Textdatensätzen beim cleanen im Normalfall 1GB Ram verbrauch haben.
Natürlich je nach Umfang der Vorverarbeitung.

Das ist im moment auch der Grund, warum ich 3 Codes zu Verarbeitung nutzte.

split.py

Die Split.py ist dafür notwendig Große Textdaten in gleichmäßig aufgeteilte Textdatein seiner Wahl aufzuteilen. Da muss man herrausfinden, was die optimale Größe ist, mit der man ohne das der Ram auf seine grenzen stößt mit schritt 2 weiter machen kann.

clear.py

Die clear.py ist der erste clear Durchlauf.
Der Code nimmt nacheinander, alle Textdaten die zuvor mit der split.py erstellt wurden im Verzeichnis und arbeitet sie ab. Am ende Speichert der code 2 neue Text Dateien. 1x die mit denn bereinigten Wörtern und 1x eine Textdatei mit allen entfernten Zeichen.
Die bereinigten Wörter, werden wieder in einer großen Textdatei ausgegeben.

Entfernt werden:

Spoiler: Was wird entfernt?

# Rauschen
rauschen_pattern = r'\b(?!http|www|html|xml|https)\w{1,2}\b'

# YouTube-Link-Muster
youtube_link_pattern = r'(?:https?:\/\/)?(?:www\.)?(?:youtube\.com|youtu\.be)\/(?:watch\?v=|embed\/|v\/)?([a-zA-Z0-9_\-]+)'

# Entfernen von unnötigen Leerzeichen, einzelnen Buchstaben und Rauschen innerhalb der Wörter

Dafür werden auch erst einmal nur die re und BeautifulSoup Bibliotheken benötigt

Das sollte die Größe ja nach Umfang der Ursprungsdatein noch einmal ordentlich schrumpfen lassen.


Meine Imput Datei, mit der ich denn test gestartet habe, war knapp 46GB Groß und ist jetzt bei 31,8GB
Nach der ersten vor-verarbeitung war das, mein Ergebnis:

Anzahl entfernter Zeichen: 4301434
Gesamtzahl der Zeichen: 31521096824

Die Gesamtzahl der Zeichen definiert, was noch enthalten ist.
Entfernt, erklärt sich von selbst.


Anschließend kann man noch einmal die Split.py nutzen um die Dateien noch einmal in die gewünschte Größen zu teilen. Man kann noch einmal mit clear.py drüber wenn man unbedingt will, oder direkt mit der
final_clear.py starten.

Da empfehle ich UNBEDINGT wenn man keine 100te von GB Ram hat, die Split.py zu nutzen.
Die final_clear.py ist ein wenig umfangreicher.

Spoiler: Was die final_clear.py macht

1. Importieren der benötigten Module:
- os
- sqlite3
- re
- textblob
- sklearn.feature_extraction.text
- sklearn.cluster
- bs4

2. Festlegen der Dateipfade:
- Verzeichnispfad für die Textdateien
- Ausgabedatei für den kombinierten Text
- Pfad zur SQLite-Datenbank

3. Erstellen einer leeren Liste für den kombinierten Text

4. Durchsuchen des Verzeichnisses und Einlesen des Inhalts jeder Textdatei in die Liste für den kombinierten Text

5. Schreiben des kombinierten Texts in eine Ausgabedatei

6. Herstellen einer Verbindung zur SQLite-Datenbank

7. Erstellen der Tabelle für Wörter und Sentiment-Analyse, falls sie nicht existieren

8. Definieren von Mustern für Rauschen und YouTube-Links

9. Extrahieren der Wörter aus dem kombinierten Text und Einfügen in die Datenbank:
- Analyse und Entfernung von HTML-Tags
- Entfernung von Leerzeichen und Rauschen
- Entfernung von YouTube-Links
- Aufteilen des Texts in einzelne Wörter
- Einfügen der Wörter in die Datenbank

10. Commit der Änderungen in der Datenbank

11. Durchführen der Sentiment-Analyse mit TextBlob:
- Abrufen der Wörter aus der Datenbank
- Durchführen der Sentiment-Analyse für jedes Wort mit TextBlob
- Einfügen der Sentiment-Ergebnisse in die Datenbank

12. Commit der Änderungen in der Datenbank

13. Festlegen der Anzahl der Cluster für K-Means-Clustering

14. Überprüfen, ob genügend Texte vorhanden sind, um die angegebene Anzahl von Clustern zu unterstützen:
- Wenn nicht genügend Texte vorhanden sind:
- Ausgabe einer Fehlermeldung

15. TF-IDF-Vektorisierung der Texte

16. Durchführen des K-Means-Clustering:
- Anwendung des K-Means-Algorithmus auf die TF-IDF-Matrix
- Zuweisung der Cluster-Labels für jeden Text

17. Anzeigen der Ergebnisse:
- Für jeden Text:
- Ausgabe des Texts und des zugewiesenen Clusters

hier habe ich heute morgen einen kleinen Codefehler behoben.
Und zwar, werden jetzt alle Textdaten nacheinander bearbeitet und in der SQLite datenbank gespeichert.
Zuvor hat der code zwar auch alle Textdatensätze bearbeitet aber auch die gesamten Daten in den Ram geladen.

Hier ist die Ausgangsdatei der SQLite Datenbank, im schnitt doppelt bis 3 mal so Groß wie die Textdatei.


Im Moment ist dies ein Pre-Alpha Projekt
Du kannst dir den/die Codes jederzeit auf der Github Seite downloaden.
Aber beachte, das es im Moment experimentell ist.
Wenn du nicht weißt, was du tust, lass es lieber.

hier gehts zu den Pre-alpha Alpha Daten
https://github.com/danny9212/Alpha-A

Daten für die Verarbeitung gibt es Legal auf vielen verschiedenen Internet seiten.

https://de.wikipedia.org/wiki/Wikip...nload#Herunterladen_aller_Seiten_als_XML-Dump

https://www.gutenberg.org/

um einmal 2 zu Inspiration zu nennen.

 

[abcddcba]

Also vorweg, ich will dir nix madig machen und finde es ok wenn du es als Spassprojekt machst, auch um zu lernen.

Punkt 1, das einzige was dein Code vermeindlich macht, ist ein Sprach-Modell auf einer kleinen Menge an Text zu trainieren. Von "KI" wuerde man da wohl nicht reden. Von LLM auch lange nicht, dafuer fehlen dir Ressourcen in jeglicher Hinsicht.

Das einzige, das mich immer gestört hat, war die Tatsache, das man halt online und oft auf die server der Entwickler beschränkt ist.

verstehe ich nicht, es gibt unzaehlige Open-Source Modelle, auch LLMs jeglicher Parameter-Groesse, quantized etc. - so kann man das auch auf Consumer Hardware laufen lassen, selbst Mobile Gerate. Zudem gibt es fuer viele auch ueber Huggingface zum Beispiel mit wenigen Zeilen Zugriff, Docker Container inkl. REST API oder meinetwegen Flask, Streamlit was auch immer Layer gibt es auch. Populaer z. B. Haystack oder sowas.

Der Plan ist, eine GUI zu implementieren Damit wirklich JEDER seine eigene KI Trainieren und nutzen kann. Das werde ich dann Beta Implementierung nennen.

Sowas gibt es eigentich auch schon, selbst in Haystack oder z.B. ein RASA Chatbot kann man Training und Fine-Tuning per GUI nutzen.

Aus deinem Text ist nicht ganz klar auf was fuer Daten du jetzt eigentlich was trainierst? Ist das Cross-Domain? Oder was spezifisches? Du nutzt ein BERT Derivat und machst dann was genau?

Wer genau ist deine Zielgruppe? Und fuer welche Tasks genau trainierst du dein Modell? Also welche Use-Cases?


Aber wie gesagt, mach ruhig - man kann nur lernen. Evtl. solltest du dann aber deinen Quellcode auch hier verlinken, evtl. als Github/Gitlab Projekt oder so. Und den Fortschritt hier dokumentieren, falls es andere interessiert.

Viel Erfolg schon mal vorab und Spass dabei!

 

[danny]

Punkt 1, das einzige was dein Code vermeindlich macht, ist ein Sprach-Modell auf einer kleinen Menge an Text zu trainieren. Von "KI" wuerde man da wohl nicht reden. Von LLM auch lange nicht, dafuer fehlen dir Ressourcen in jeglicher Hinsicht.

Kleine menge?
ich habe ein paar 100 GB an Textdaten.

Huggingface

ich weiß, habe neo doch erwähnt.

was spezifisches?

Eine eigene KI, einfach, weil ich lust drauf habe.

So wie nicht jeder Lust auf Cloud server hat, und sich lieber einen eigenen server in die Bude stellt, so mach ich halt eine KI.

Das einzige, was mein code gerade macht, ist das Model zu trainieren.
Die Text menge, wird nach und nach nach oben gedreht, Stabilität vorausgesetzt.

Was ich gerade vorgestellt habe, ist einfach nur der Start.

 

[ErichH.]

Ok, du trainierst ein Language Model.
Grundsätzlich sehr interessant, was du schreibst, aber aufgrund deines Ausdrucks schwer zu lesen.

Bist du "vom Fach" oder irgendwie in der Materie? Ich vermute nicht, sonst würdest du das, was du da trainierst, nicht KI nennen. Das macht im Allgemeinen nur das Marketing.

Zeig doch mal ein schematisches Bild deines Models oder eine strukturierte Darstellung, würde mich interessieren.
Auf welcher Hardware trainierst du?

Ich habe auch schon mal ein Deep Learning-Modell erstellt (streng genommen zwei) - zum Generieren künstlicher Bilder. Basis waren eine GAN und VQ-VAE, habe den Aufbau etwas abgewandelt und auch eigene Convolution-Blöcke erstellt und verschiedene Aufbauten durchgetestet.

 

[danny]

Das Thema ist nicht tot, ich bin bloß noch am optimieren der Vorverarbeitung der Text-datensätze.
aber ich denke, heute werde ich die ersten Codes einmal vorlegen können.
Die größten Änderungen, sind eigentlich Cluster, N-Gramm-Erkennung und eine SQLite-Datenbank.
Im Grunde also alles.

Im moment, überlege ich ua. noch, wie ich Kontext Berücksichtigung am besten implementiere. Einfach wegen Satzzeichen und Zahlen.

Also, was auf jeden fall ein Thema ist, ist der Speicher. 39,3mb werden nach erfolgreichem packen in die SQLite-Datenbank zu 100,4mb. Und, ich habe ein paar viele 100GB an textdaten die bearbeitet werden müssen. Und damit ist das eigentliche Model noch nicht einmal trainiert.

zum Generieren künstlicher Bilder.

Ja, das wäre auch so ein Punkt, denn ich gerne in meiner KI implementieren würde.
Das Thema ist in seinen Möglichkeiten grenzenlos.
Aber in der Umsetzung schnell eine Tortur.

Zeig doch mal ein schematisches Bild deines Models

Spoiler: schematisches Bild

+---------------------------+
| |
| Textdokumente |
| |
+----------+----------------+
|
v
+--------------+ Lesen +-------------------+
| |---------->| |
| Verzeichnis | | Textdokumente |
| |<----------| sauber.txt |
+--------------+ Schreiben +-------------------+
|
v
+--------------+ Verbindung +------------------+
| |------------>| |
| SQLite- | | word_database.db |
| Datenbank |<------------| |
| | herstellen | |
+--------------+ +------------------+
|
v
+--------------+ Erstellen +----------------+
| |-------------->| |
| Tabelle | | words |
| erstellen | | |
| |<--------------| |
+--------------+ Erstellen +----------------+
|
v
+--------------+ Vorverarbeitung +----------------+
| |---------------->| |
| Texte | | Stoppwörter |
| durchsuchen | | entfernen |
| |<----------------| |
+--------------+ Vorverarbeitung +----------------+
|
v
+--------------+ Vorverarbeitung +----------------+
| |---------------->| |
| Texte | | Stemming |
| vorverarbeiten| | durchführen |
| |<----------------| |
+--------------+ Vorverarbeitung +----------------+
|
v
+--------------+ Vorverarbeitung +----------------+
| |---------------->| |
| Texte | | Wörter und |
| vorverarbeiten| | Bigramme in |
| |<----------------| Datenbank |
+--------------+ Vorverarbeitung +----------------+
|
v
+--------------+ Sentiment- +-----------------+
| | Analyse | |
| Texte |-------------->| Sentiments |
| aus Datenbank | | Tabelle |
| abrufen | | |
| |<--------------| |
+--------------+ Sentiment- +-----------------+
| Analyse
v
+--------------+ TF-IDF- +-------------------+
| | Vektorisierung | |
| Texte |---------------->| TF-IDF- |
| aus | | Matrix |
| Datenbank |<----------------| |
+--------------+ TF-IDF- +-------------------+
| Vektorisierung
v
+--------------+ K-Means- +------------------+
| | Clustering | |
| TF-IDF- |---------------->| Clusters |
| Matrix | | |
| |<----------------| |
+--------------+ K-Means- +------------------+
| Clustering
v
+--------------+ Ergebnisse +------------------+
| |------------->| |
| Texte | | Clusternummer |
| aus | | anzeigen |
| Datenbank |<-------------| |
+--------------+ Ergebnisse +------------------+​

Es kann sich natürlich jederzeit wieder komplett verändern.
Nicht umsonst ist es ein Tagebuch


hab das schematisches Bild und eine strukturierte Darstellung noch mal per txt. angehängt. Weils im CB editor komisch ausschaut.

 

[danny]

https://github.com/danny9212/Alpha-A/tree/main/Vortraining

 

[danny]

Ich habe den final_clear.py aktualisiert.
Der Code liest und verarbeitet jetzt jede Textdatei einzeln. Der kombinierte Text wird schrittweise in die Ausgabedatei geschrieben, und die Wörter und Sentiments werden in die SQLite-Datenbank eingefügt, während jede Textdatei verarbeitet wird. Dadurch wird der Speicherbedarf reduziert, da nicht der gesamte Text aller Dateien im Speicher gehalten wird.

 

[danny]

Update

ich habe eine neue Datei in einem Optionalen Ordner hinzugefügt
https://github.com/danny9212/Alpha-A/tree/main/Vortraining/Optional

:

Spoiler: Erklärung

Der Code durchsucht ein Verzeichnis und seine Unterverzeichnisse nach Dateien. Wenn eine Datei eine ZIP-Datei ist, öffnet der Code die ZIP-Datei und extrahiert den Inhalt. Wenn die Dateiendung ".py" ist, wird der Python-Code in eine Ausgabedatei für Python-Code geschrieben. Wenn die Dateiendung ".md" oder ".txt" ist, wird der Inhalt in eine Textausgabedatei geschrieben. Wenn eine Datei keine ZIP-Datei ist, wird der Inhalt in die Textausgabedatei geschrieben. Wenn ein Fehler auftritt, wird eine Fehlermeldung in eine separate Fehlerausgabedatei geschrieben. Der Code überprüft auch Unterarchive innerhalb von ZIP-Dateien und behandelt sie entsprechend, indem er sie entweder extrahiert oder bei einer ZIP-Datei den Inhalt analysiert.

Das Dient vor allem, um Code Dateien, für das Training, inkl. deren Erklärungen isoliert zu bekommen.


Früher oder Später, folgen noch weitere Sprachen.
Java und C++ sind auf jedenfall sicher.