Einführung
Dieser Artikel beschreibt eine neue Version eines maschinellen Lernprogramms, das auf der Gittertheorie basiert. Der Hauptvorteil dieser Version ist eine Schnittstelle für Python-Programmierer zu effizienten Algorithmen, die in C ++ programmiert sind.
Heutzutage haben maschinelle Lernverfahren (wie Faltungs-Neuronale Netze, zufällige Wälder und Support-Vektor-Maschinen) ein sehr hohes Niveau erreicht und übertreffen die Menschen bei der Sprach-, Video- und Bilderkennung. Sie können jedoch keine Argumente für die Richtigkeit ihrer Schlussfolgerungen vorlegen.
Andererseits weisen symbolische Ansätze für maschinelles Lernen (induktive Logikprogrammierung, Lernabdeckung unter Verwendung von Ganzzahlprogrammierung) einen nachweislich sehr hohen Rechenaufwand auf und sind praktisch nicht auf Stichproben selbst einer relativ kleinen Größe anwendbar.
Der hier beschriebene Ansatz verwendet probabilistische Algorithmen, um diese Probleme zu vermeiden. Die ICF-Methode des maschinellen Lernens verwendet die Techniken der modernen algebraischen Gittertheorie (Analyse formaler Konzepte) und der Wahrscheinlichkeitstheorie (insbesondere Markov-Ketten). Jetzt benötigen Sie jedoch keine Kenntnisse der fortgeschrittenen Mathematik, um Programme mit dem ICF-System zu verwenden und zu erstellen. Der Autor hat eine Bibliothek erstellt (vkf.cp38-win32.pyd unter Windows oder vkf.cpython-38-x86_64-linux-gnu.so unter Linux), um den Zugriff auf das Programm über eine Schnittstelle zu ermöglichen, die Python-Programmierer verstehen können.
In Bezug auf den beschriebenen Ansatz gibt es einen elterlichen Ansatz - erfunden zu Beginn der 80er Jahre des 20. Jahrhunderts, Doktor der technischen Wissenschaften. prof. VK. Finn JSM-Methode zur automatischen Hypothesengenerierung. Es hat sich nun, wie sein Schöpfer sagt, zu einer Methode zur automatisierten Unterstützung der wissenschaftlichen Forschung entwickelt. Es ermöglicht Ihnen, Methoden der Argumentationslogik zu verwenden, die Stabilität der gefundenen Hypothesen beim Erweitern der Trainingsstichprobe zu überprüfen und die Ergebnisse von Vorhersagen unter Verwendung verschiedener Strategien des JSM-Denkens zu kombinieren.
Leider haben der Autor dieser Notiz und seine Kollegen einige theoretische Mängel der JSM-Methode entdeckt und untersucht:
- Im schlimmsten Fall kann die Anzahl der erzeugten Ähnlichkeiten im Vergleich zur Größe der Eingabedaten (Trainingsmuster) exponentiell groß sein.
- (NP-).
- .
- «» , .
- .
Die Forschung des Autors ist in Kapitel 2 seiner Dissertationsarbeit zusammengefasst . Der letzte Punkt wurde kürzlich vom Autor entdeckt, beendet aber seiner Meinung nach den Ansatz der erweiterten Stichprobe.
Schließlich bietet die JSM-Community keinen Zugriff auf den Quellcode ihrer Systeme. Darüber hinaus erlauben die verwendeten Programmiersprachen (Fort und C #) ihre Verwendung durch die breite Öffentlichkeit nicht. Die einzige kostenlose C ++ - Version des JSM-Lösers, die dem Autor bekannt ist (von T.A. VolkovaRobofreak) enthält einen störenden Fehler, der manchmal zu einer abnormalen Beendigung der Berechnungen führt.
Zunächst wollte der Autor den für das VKF-Methodensystem entwickelten Encoder mit der JSM-Community teilen. Daher legte er alle Algorithmen, die gleichzeitig für JSM- und VKF-Systeme gelten, in einer separaten Bibliothek ab (vkfencoder.cp38-win32.pyd unter Windows oder vkfencoder.cpython-38-x86_64-linux-gnu.so unter Linux). ... Leider stellte sich heraus, dass diese Algorithmen von der JSM-Community nicht beansprucht wurden. Die VKF-Bibliothek implementiert diese Algorithmen (z. B. die vkf.FCA-Klasse), verlässt sich jedoch darauf, Tabellen nicht aus Dateien, sondern direkt über die Weboberfläche auszufüllen. Hier verwenden wir die vkfencoder-Bibliothek.
1 Verfahren zum Arbeiten mit der Bibliothek für diskrete Funktionen
Nehmen wir an, der Leser weiß, wie er den MariaDB-Server + MariaDB Connector / C installiert hat (standardmäßig verwenden wir die IP-Adresse 127.0.0.1:3306 und den Benutzer 'root' mit dem Passwort 'toor'). Beginnen wir mit der Installation der Bibliotheken vkfencoder und vkf in der virtuellen Demo-Umgebung und der Erstellung einer leeren MariaDB-Datenbank mit dem Namen "pilz".
krrguest@amd2700vii:~/src$ python3 -m venv demo
krrguest@amd2700vii:~/src$ source demo/bin/activate
(demo) krrguest@amd2700vii:~/src$ cd vkfencoder
(demo) krrguest@amd2700vii:~/src/vkfencoder$ python3 ./setup.py build
(demo) krrguest@amd2700vii:~/src/vkfencoder$ python3 ./setup.py install
(demo) krrguest@amd2700vii:~/src/vkfencoder$ cd ../vkf
(demo) krrguest@amd2700vii:~/src/vkf$ python3 ./setup.py build
(demo) krrguest@amd2700vii:~/src/vkf$ python3 ./setup.py install
(demo) krrguest@amd2700vii:~/src/vkf$ cd ../demo
(demo) krrguest@amd2700vii:~/src/demo$ mysql -u root -p
MariaDB [(none)]> CREATE DATABASE IF NOT EXISTS mushroom;
MariaDB [(none)]> exit;
Als Ergebnis der Arbeit wird die Datenbank 'pilz' im Ordner ~ / src / demo / lib / python3.8 / site-packages / vkfencoder-1.0.3-py3.8-linux-x86_64.egg / die
Datei vkfencoder.cpython-38 angezeigt -x86_64-linux-gnu.so und die
Datei vkf.cpython werden im Ordner ~ / src / demo / lib / python3.8 / site-packages / vkf-2.0.1-py3.8-linux-x86_64.egg / angezeigt 38-x86_64-linux-gnu.so
Starten Sie Python3 und führen Sie ein CCF-Experiment für das Mushrooms-Array aus. Es wird davon ausgegangen, dass sich 3 Dateien im Ordner ~ / src / demo / files / befinden (lung.xml, MUSHROOMS.train, MUSHROOMS.rest). Die Struktur dieser Dateien wird im nächsten Abschnitt beschrieben. Die erste Datei 'fungrooms.xml' definiert die Struktur des unteren Halbgitters anhand der Werte der einzelnen Attribute, die Pilze beschreiben. Die zweite und dritte Datei sind die Dateien 'agaricus-lepiota.data', die durch einen Zufallszahlengenerator ungefähr in zwei Hälften geteilt werden - das digitalisierte Buch "Identifier of North American Mushrooms", das 1981 in New York veröffentlicht wurde. Die folgenden Namen sind 'Encoder', 'Lattices', ' Züge 'und' Tests 'sind die Namen von Tabellen in der Datenbank' Pilz 'für die Codierung von Merkmalswerten durch Bit-Teilzeichenfolgen, Abdeckungsrelationen für Halbgitterdiagramme für diese Werte.Trainings- und Testbeispiele.
(demo) krrguest@amd2700vii:~/src/demo$ Python3
>>> import vkfencoder
>>> xml = vkfencoder.XMLImport('./files/mushrooms.xml', 'encoder', 'lattices', 'mushroom', '127.0.0.1', 'root', 'toor')
>>> trn = vkfencoder.DataImport('./files/MUSHROOMS.train', 'e', 'encoder', 'trains', 'mushroom', '127.0.0.1', 'root', 'toor')
>>> tst = vkfencoder.DataImport('./files/MUSHROOMS.rest', 'e', 'encoder', 'tests', 'mushroom', '127.0.0.1', 'root', 'toor')
Das 'e' in den letzten beiden Zeilen entspricht der Essbarkeit des Pilzes (so wird das Zielmerkmal in diesem Array codiert).
Es ist wichtig zu beachten, dass es eine vkfencoder.XMLExport-Klasse gibt, mit der Sie Informationen aus zwei Tabellen 'encoder' und 'gitter' in einer XML-Datei speichern können, die nach Änderungen von der vkfencoder.XMLImport-Klasse erneut verarbeitet werden können.
Nun wenden wir uns dem eigentlichen VKF-Experiment zu: Verbinden Sie die Encoder, laden Sie die zuvor berechneten Hypothesen (falls vorhanden), berechnen Sie die zusätzliche Anzahl (100) von Hypothesen in die angegebenen Anzahl (4) Streams und speichern Sie sie in der Tabelle 'vkfhyps'.
>>> enc = vkf.Encoder('encoder', 'mushroom', '127.0.0.1', 'root', 'toor')
>>> ind = vkf.Induction()
>>> ind.load_discrete_hypotheses(enc, 'trains', 'vkfhyps', 'mushroom', '127.0.0.1', 'root', 'toor')
>>> ind.add_hypotheses(100, 4)
>>> ind.save_discrete_hypotheses(enc, 'vkfhyps', 'mushroom', '127.0.0.1', 'root', 'toor')
Sie können eine Python-Liste aller nichttrivialen Paare (feature_name, feature_value) für die CCF-Hypothese mit der Nummer ndx erhalten
>>> ind.show_discrete_hypothesis(enc, ndx)
Eine der Hypothesen für eine Entscheidung über die Essbarkeit des Pilzes hat die Form
[('gill_attachment', 'free'), ('gill_spacing', 'close'), ('gill_size', 'broad'), ('stalk_shape', 'enlarging'), ('stalk_surface_below_ring', 'scaly'), ('veil_type', 'partial'), ('veil_color', 'white'), ('ring_number', 'one'), ('ring_type', 'pendant')]
Aufgrund des probabilistischen Charakters der Algorithmen der CCF-Methode kann sie möglicherweise nicht generiert werden, aber der Autor hat bewiesen, dass bei einer ausreichend großen Anzahl generierter CCF-Hypothesen eine sehr ähnliche Hypothese entsteht, die die Zieleigenschaft für wichtige Testfälle fast genauso gut vorhersagt. Details finden Sie in Kapitel 4 der Dissertation des Autors.
Schließlich wenden wir uns der Vorhersage zu. Wir erstellen ein Testmuster, um die Qualität der generierten Hypothesen zu bewerten und gleichzeitig die Zieleigenschaft ihrer Elemente vorherzusagen
>>> tes = vkf.TestSample(enc, ind, 'tests', 'mushroom', '127.0.0.1', 'root', 'toor')
>>> tes.correct_positive_cases()
>>> tes.correct_negative_cases()
>>> exit()
2 Beschreibung der Datenstruktur
2.1 Gitterstrukturen auf diskreten Merkmalen
Die Klasse vkfencoder.XMLImport analysiert eine XML-Datei, die die Reihenfolge zwischen Feature-Werten beschreibt, erstellt und füllt zwei Tabellen 'Encoder' (Konvertieren jedes Werts in eine Bitfolge) und 'Gitter' (Speichern von Beziehungen zwischen den Werten eines Features).
Die Struktur der Eingabedatei sollte wie folgt sein
<?xml version="1.0"?>
<document name="mushrooms_db">
<attribute name="cap_color">
<vertices>
<node string="null" char='_'></node>
<node string="brown" char='n'></node>
<node string="buff" char='b'></node>
<node string="cinnamon" char='c'></node>
<node string="gray" char='g'></node>
<node string="green" char='r'></node>
<node string="pink" char='p'></node>
<node string="purple" char='u'></node>
<node string="red" char='e'></node>
<node string="white" char='w'></node>
<node string="yellow" char='y'></node>
</vertices>
<edges>
<arc source="brown" target="null"></arc>
<arc source="buff" target="brown"></arc>
<arc source="buff" target="yellow"></arc>
<arc source="cinnamon" target="brown"></arc>
<arc source="cinnamon" target="red"></arc>
<arc source="gray" target="null"></arc>
<arc source="green" target="null"></arc>
<arc source="pink" target="red"></arc>
<arc source="pink" target="white"></arc>
<arc source="purple" target="red"></arc>
<arc source="red" target="null"></arc>
<arc source="white" target="null"></arc>
<arc source="yellow" target="null"></arc>
</edges>
</attribute>
</document>
Das obige Beispiel zeigt die Reihenfolge zwischen den Werten des dritten Merkmals 'cap_color' (Hutfarbe) für das Mushrooms-Array aus dem Machine Learning Data Repository (Universität von Kalifornien, Irvine). Jedes 'Attribut'-Feld repräsentiert eine Gitterstruktur auf den Werten des entsprechenden Attributs. In unserem Beispiel entspricht die Gruppe dem diskreten Attribut 'cap_color'. Die Liste aller Merkmalswerte bildet eine Untergruppe. Wir haben einen Wert hinzugefügt, um triviale (fehlende) Ähnlichkeiten anzuzeigen. Die restlichen Werte entsprechen der Beschreibung in der Begleitdatei 'agaricus-lepiota.names'.
Die Reihenfolge zwischen ihnen wird durch den Inhalt der Untergruppe dargestellt. Jedes Element beschreibt eine spezifischere / allgemeinere Beziehung zwischen Paaren von charakteristischen Werten. Zum Beispiel bedeutet ,, dass eine rosa Pilzkappe spezifischer ist als eine rote Kappe.
Der Autor hat den Satz über die Richtigkeit der Darstellung bewiesen, die vom Konstruktor der Klasse vkfencoder.XMLImport generiert und in der Tabelle 'encoder' gespeichert wurde. Sein Algorithmus- und Korrektheitssatzbeweis verwendet einen modernen Zweig der Gittertheorie, der als formale Konzeptanalyse bekannt ist. Für Einzelheiten wird der Leser erneut auf die Dissertationsarbeit des Autors verwiesen (Kapitel 1).
2.2 Beispielstruktur für diskrete Merkmale
Zunächst sollte beachtet werden, dass der Leser seinen eigenen Trainings- und Testfalllader in der Datenbank implementieren oder die in der Bibliothek verfügbare Klasse vkfencoder.DataImport verwenden kann. Im zweiten Fall sollte der Leser berücksichtigen, dass sich das Zielmerkmal an der ersten Position befinden und aus einem Zeichen bestehen muss (z. B. '+' / '-', '1' / '0' oder 'e' / 'p').
Das Trainingsbeispiel sollte eine CSV-Datei (mit durch Kommas getrennten Werten) sein, die Trainingsbeispiele und Zählerbeispiele (Beispiele ohne die Eigenschaft target) beschreibt.
Die Struktur der Eingabedatei sollte wie folgt sein
e,f,f,g,t,n,f,c,b,w,t,b,s,s,p,w,p,w,o,p,k,v,d
p,x,s,p,f,c,f,c,n,u,e,b,s,s,w,w,p,w,o,p,n,s,d
p,f,y,g,f,f,f,c,b,p,e,b,k,k,b,n,p,w,o,l,h,v,g
p,x,y,y,f,f,f,c,b,p,e,b,k,k,n,n,p,w,o,l,h,v,p
e,x,y,b,t,n,f,c,b,e,e,?,s,s,e,w,p,w,t,e,w,c,w
p,f,f,g,f,f,f,c,b,g,e,b,k,k,n,p,p,w,o,l,h,y,g
p,x,f,g,f,f,f,c,b,p,e,b,k,k,p,n,p,w,o,l,h,y,g
p,x,f,y,f,f,f,c,b,h,e,b,k,k,n,b,p,w,o,l,h,y,g
p,f,f,y,f,f,f,c,b,h,e,b,k,k,p,p,p,w,o,l,h,y,g
p,x,y,g,f,f,f,c,b,h,e,b,k,k,p,p,p,w,o,l,h,v,d
p,x,f,g,f,c,f,c,n,u,e,b,s,s,w,w,p,w,o,p,n,v,d
p,x,y,g,f,f,f,c,b,h,e,b,k,k,p,b,p,w,o,l,h,v,g
e,f,y,g,t,n,f,c,b,n,t,b,s,s,p,g,p,w,o,p,k,y,d
e,f,f,e,t,n,f,c,b,p,t,b,s,s,p,p,p,w,o,p,k,v,d
p,f,y,g,f,f,f,c,b,p,e,b,k,k,p,b,p,w,o,l,h,y,p
Jede Zeile hier beschreibt ein Trainingsbeispiel. Die erste Position enthält je nach Essbarkeit / Toxizität des beschriebenen Pilzes 'e' oder 'p'. Die restlichen Positionen (durch Kommas getrennt) enthalten Buchstaben (Kurznamen) oder Zeichenfolgen (vollständige Namen der Werte des entsprechenden Attributs). Zum Beispiel entspricht die vierte Position dem Attribut 'cup_color', wobei 'g', 'p', 'y', 'b' und 'e' für "grau", "pink", "gelb", "sand" und "rot" stehen. , beziehungsweise. Das Fragezeichen in der Mitte der obigen Tabelle zeigt einen fehlenden Wert an. Die Werte der verbleibenden (Nichtziel-) Merkmale können jedoch Zeichenfolgen sein. Es ist wichtig zu beachten, dass beim Speichern in der Datenbank Leerzeichen in ihren Namen durch '_' Zeichen ersetzt werden.
Die Datei mit Testfällen hat dieselbe Form, nur wird dem System nicht das tatsächliche Vorzeichen des Beispiels mitgeteilt, und seine Vorhersage wird damit verglichen, um die Qualität der generierten Hypothesen und ihre Vorhersagekraft zu berechnen.
2.3 Beispielstruktur für kontinuierliche Merkmale
In diesem Fall sind wieder Optionen möglich: Der Leser kann seinen eigenen Trainer und Testfalllader in der Datenbank implementieren oder die in der Bibliothek verfügbare Klasse vkfencoder.DataLoad verwenden. Im zweiten Fall sollte der Leser berücksichtigen, dass sich das Zielmerkmal an der ersten Position befindet und aus einer natürlichen Zahl besteht (z. B. 0, 7, 15).
Das Trainingsbeispiel muss eine CSV-Datei (mit durch ein Trennzeichen getrennten Werten) sein, die Trainingsbeispiele und Zählerbeispiele (Beispiele ohne die Eigenschaft target) beschreibt.
Die Struktur der Eingabedatei sollte wie folgt sein
"quality";"fixed acidity";"volatile acidity";"citric acid";"residual sugar";"chlorides";"free sulfur dioxide";"total sulfur dioxide";"density";"pH";"sulphates";"alcohol"
5;7.4;0.7;0;1.9;0.076;11;34;0.9978;3.51;0.56;9.4
5;7.8;0.88;0;2.6;0.098;25;67;0.9968;3.2;0.68;9.8
5;7.8;0.76;0.04;2.3;0.092;15;54;0.997;3.26;0.65;9.8
6;11.2;0.28;0.56;1.9;0.075;17;60;0.998;3.16;0.58;9.8
5;7.4;0.7;0;1.9;0.076;11;34;0.9978;3.51;0.56;9.4
5;7.4;0.66;0;1.8;0.075;13;40;0.9978;3.51;0.56;9.4
5;7.9;0.6;0.06;1.6;0.069;15;59;0.9964;3.3;0.46;9.4
7;7.3;0.65;0;1.2;0.065;15;21;0.9946;3.39;0.47;10
7;7.8;0.58;0.02;2;0.073;9;18;0.9968;3.36;0.57;9.5In unserem Fall sind dies die ersten Zeilen der Datei 'vv_red.csv', die aus der Datei 'winequality-red.csv' von portugiesischen Rotweinen aus dem Array Wine Quality des UCI-Datenrepositorys generiert wurde, um maschinelle Lernverfahren zu testen, indem die letzte Spalte bis zum Anfang neu angeordnet wird. Es ist wichtig zu beachten, dass beim Speichern in der Datenbank Leerzeichen in ihren Namen durch '_' Zeichen ersetzt werden.
3 CCF-Experiment an Beispielen mit kontinuierlichen Merkmalen
Wie bereits geschrieben, werden wir die Arbeit am Wine Quality-Array aus dem UCI-Repository demonstrieren. Beginnen wir mit der Erstellung einer leeren Datenbank unter MariaDB mit dem Namen 'red_wine'.
(demo) krrguest@amd2700vii:~/src/demo$ mysql -u root -p
MariaDB [(none)]> CREATE DATABASE IF NOT EXISTS red_wine;
MariaDB [(none)]> exit;
Als Ergebnis der Arbeit wird die Datenbank 'red_wine' angezeigt.
Wir starten Python3 und führen ein VKF-Experiment mit dem Wine Quality-Array durch. Es wird davon ausgegangen, dass sich im Ordner ~ / src / demo / files / eine Datei vv_red.csv befindet. Die Struktur dieser Dateien wurde im vorherigen Absatz beschrieben. Die folgenden Namen 'Verges', 'Complex', 'Train' und 'Tests' sind die Namen von Tabellen in der 'red_wine'-Datenbank für Schwellenwerte (sowohl für die anfänglichen als auch für durch Regression berechnete Merkmale), Koeffizienten signifikanter logistischer Regressionen zwischen Funktionspaare, Trainings- und Testfälle.
(demo) krrguest@amd2700vii:~/src/demo$ Python3
>>> import vkfencoder
>>> nam = vkfencoder.DataLoad('./files/vv_red.csv', 7, 'verges', 'trains', 'red_wine', ';', '127.0.0.1', 'root', 'toor')
Das zweite Argument legt den Schwellenwert fest (in unserem Fall 7), oberhalb dessen das Beispiel als positiv deklariert wird. Streit ';' stimmt mit dem Trennzeichen überein (der Standardwert ist ',').
Wie in der vorherigen Anmerkung des Autors angegeben , unterscheidet sich das Verfahren vom Fall diskreter Merkmale. Zuerst berechnen wir die logistischen Regressionen mit der Klasse vkf.Join, deren Koeffizienten in der 'komplexen' Tabelle gespeichert sind.
>>> join = vkf.Join('trains', 'red_wine', '127.0.0.1', 'root', 'toor')
>>> join.compute_save('complex', 'red_wine', '127.0.0.1', 'root', 'toor')
Mithilfe der Informationstheorie berechnen wir nun die Schwellenwerte mithilfe der vkf.Generator-Klasse, die zusammen mit dem Maximum und dem Minimum in der Tabelle 'verges' gespeichert sind.
>>> gen = vkf.Generator('complex', 'trains', 'verges', 'red_wine', 7, '127.0.0.1', 'root', 'toor')
Das fünfte Argument legt die Anzahl der Schwellenwerte für die ursprünglichen Features fest. Standardmäßig (und mit einem Wert von 0) wird es als Logarithmus der Anzahl der Features berechnet. Die Regressionen suchen nach einer einzigen Schwelle.
Nun wenden wir uns dem eigentlichen VKF-Experiment zu: Wir verbinden die Encoder, laden die zuvor berechneten Hypothesen (falls vorhanden), berechnen die zusätzliche Anzahl (300) von Hypothesen in der angegebenen Anzahl (8) von Streams und speichern sie in der Tabelle 'vkfhyps'.
>>> qual = vkf.Qualifier('verges', 'red_wine', '127.0.0.1', 'root', 'toor')
>>> beg = vkf.Beget('complex', 'red_wine', '127.0.0.1', 'root', 'toor')
>>> ind = vkf.Induction()
>>> ind.load_continuous_hypotheses(qual, beg, 'trains', 'vkfhyps', 'red_wine', '127.0.0.1', 'root', 'toor')
>>> ind.add_hypotheses(300, 8)
>>> ind.save_continuous_hypotheses(qual, 'vkfhyps', 'red_wine', '127.0.0.1', 'root', 'toor')
Sie können eine Python-Liste mit Tripeln (Funktionsname, (untere_Bindung, obere_Bindung)) für die CCF-Hypothese mit der Nummer ndx erhalten
>>> ind.show_continuous_hypothesis(enc, ndx)
Schließlich wenden wir uns der Vorhersage zu. Wir erstellen ein Testmuster, um die Qualität der generierten Hypothesen zu bewerten und gleichzeitig die Zieleigenschaft ihrer Elemente vorherzusagen
>>> tes = vkf.TestSample(qual, ind, beg, 'trains', 'red_wine', '127.0.0.1', 'root', 'toor')
>>> tes.correct_positive_cases()
>>> tes.correct_negative_cases()
>>> exit()
Da wir nur eine Datei haben, haben wir hier das Trainingsset als Testfälle verwendet.
4. Hinweis zum Hochladen von Dateien
Ich habe die aiofiles-Bibliothek verwendet, um Dateien (wie 'fungrooms.xml') auf einen Webserver hochzuladen. Hier ist ein Code, den Sie vielleicht nützlich finden
import aiofiles
import os
import vkfencoder
async def write_file(path, body):
async with aiofiles.open(path, 'wb') as file_write:
await file_write.write(body)
file_write.close()
async def xml_upload(request):
#determine names of tables
encoder_table_name = request.form.get('encoder_table_name')
lattices_table_name = request.form.get('lattices_table_name')
#Create upload folder if doesn't exist
if not os.path.exists(Settings.UPLOAD_DIR):
os.makedirs(Settings.UPLOAD_DIR)
#Ensure a file was sent
upload_file = request.files.get('file_name')
if not upload_file:
return response.redirect("/?error=no_file")
#write the file to disk and redirect back to main
short_name = upload_file.name.split('/')[-1]
full_path = f"{Settings.UPLOAD_DIR}/{short_name}"
try:
await write_file(full_path, upload_file.body)
except Exception as exc:
return response.redirect('/?error='+ str(exc))
return response.redirect('/ask_data')
Fazit
Die Bibliothek vkf.cpython-38-x86_64-linux-gnu.so enthält viele versteckte Klassen und Algorithmen. Sie verwenden solche fortgeschrittenen mathematischen Konzepte wie geschlossene Operationen, verzögerte Auswertung, gepaarte Markov-Ketten, Übergangszustände der Markov-Kette, Metrik der Gesamtvariation usw.
In der Praxis Experimente mit Arrays des Datenrepositorys für maschinelles Lernen (University of California in Irvine) ) zeigten die tatsächliche Anwendbarkeit des C ++ - Programms 'VKF-Methode' auf mittelgroße Daten (das Adult-Array enthält 32560 Trainings- und 16280 Testfälle).
Das System der 'VKF-Methode' übertraf (in Bezug auf die Vorhersagegenauigkeit) das CLIP3-System (Integer Programming Coverage Learning v.3) in einem SPECT-Array, wobei CLIP3 ein von den Autoren des SPECT-Arrays erstelltes Programm ist. Auf dem Pilzarray (zufällig aufgeteilt in Trainings- und Testproben) zeigte das VKF-Methodensystem eine 100% ige Genauigkeit (sowohl in Bezug auf das Kriterium der Pilztoxizität als auch in Bezug auf das Kriterium der Essbarkeit). Das Programm wurde auch auf das Adult-Array angewendet, um über eine Million Hypothesen (keine Störungen) zu generieren.
Die Quellcodes der vkf CPython-Bibliothek sind unter savannah.nongnu.org vormoderiert. Die Codes für die vkfencoder-Hilfsbibliothek sind bei Bitbucket erhältlich .
Der Autor dankt seinen Kollegen und Studenten (D.A. Anokhin, E.D. Baranova, I.V. Nikulin, E.Uu. Sidorova, L.A. Yakimova) für ihre Unterstützung, nützliche Diskussionen und gemeinsame Forschung. Wie üblich ist der Autor jedoch allein für alle bestehenden Mängel verantwortlich.