Dr. Manque

Wenn die Ergebnisse gleich gut sind. dann kann man ja nicht meckern. Ist Deine Plus/Minus-Zeichensetzung noch irgendwo genauer beschrieben? Aus dem Excel-Beispiel kann ich das Verfahren nicht erkennen. Albert

Hallo Juan, ja die Parallelen liegen in der Wahl der EC als Chancenart und in der Beobachtungsphase vorher. Nun kann man die Beobachtungen des Grafen nicht direkt mit einem Algorithmus vergleichen, der Ähnliches anstrebt. Sicher wird der Graf Trefferhäufigkeiten gezählt und in Relation zu bestimmten Mustern gesetzt haben, die er sich dann notiert und zu Regeln umgeformt hat. Oder er hatte die Fähigkeit, die gewinnfähigen Muster intuitiv zu erfassen und in seinem Gedächtnis festzuhalten. Andere Möglichkeiten gibt es ja gar nicht. Ein Algorithmus, bzw. ein Programm arbeitet immer sequentiell korrekt in kleinen Schritten, also ganz anders als das Auge, bzw. das Gehirn des Menschen. Parallelverarbeitung von Informationen - charakteristisch für die biologischen Informationsverarbeitungssysteme - ist in der digitalen Welt sehr schwierig und aufwändig. Es wird z.B. innerhalb der KI sehr viel daran geforscht, Intuition in Algorithmen abzubilden. Der Durchbruch ist wohl noch nicht geschafft, aber er ist in Sicht. Zurück zum "EC-FigurenLearning". Dort werden innerhalb einer "Permvergangenheit" von 300 bis 400 Coups Trefferhäufigkeiten und Trefferabstände der Figurenlängen 2 bis 8 gezählt und in einer Tabelle gesammelt. Das ist die Lernphase. Aus der Lerntabelle werden mittels einer Art Prozentrechnung Prioritäten ermittelt und entsprechend wird gesetzt. Das ist die Kannphase. Nichts anderes hat auch der Graf gemacht, zuerst beobachten und Muster lernen, dann anwenden. Die Ergebnisse zeigen mir, dass maschinelles Lernen im Roulette keine heiße Luft ist. Aber ich stehe da noch ganz am Anfang. Immerhin 2 Modelle für EC-FigurenLearning laufen recht gut und ein Modell für TVS-Figurenlearning. Meine Versuche, die Lernmatrix von HEBALINO nachzuahmen, womit er innerhalb von 6 Wochen 110.000€ aus dem CC geholt hat, sind bisher gescheitert. Zusammen mit Egoist ist geplant, Neuronale Netze ("Deep Learning") anzuwenden. Das wird eine sehr anspruchsvolle aber spannende Geschichte. In dem endlosen Streit zwischen Sachse und Sven-DC hat natürlich Sven-DC Recht, denn Logik und Mustererkennung sind die technischen Mittel, um im Roulette zu gewinnen. Der Siegeszug des Computers erklärt sich nicht nur daher, dass er schnell und genau rechnen kann, sondern auch daher, dass er ein ein guter Symbolverarbeiter ist. Die Zahlen auf dem Roulettetableau sind ja keine Mengengrößen wie Geld, Kartoffeln etc., sondern Namen, also Symbole für Satzpositionen mit bestimmten Wertigkeiten. Albert

Hallo Cheval, dass Du hier liest, kann nicht stimmen. Die Fragen, die Du stellst, sind im Forum mehrfach beantwortet. Stinksauer bin ich besonders wegen "Produziert dein EC Learn Plus?", denn ich habe nicht nur die bisher getesteten Lernverfahren beschrieben, sondern auch die Ergebnisse bis hinunter zum Coup tabelliert. Was Newfish betrifft: ja, er ist ein Proll, aber auch ein talentierter und erfolgreicher Gambler. Hoffentlich liest Du in Zukunft gründlicher. Albert

Hallo Ego, alles Persönliche lassen wir mal weg. Schade, dass Du die 37 Buttons nicht im Gitter halten konntest. Ich werde es trotzdem auch noch probieren. Die Crux beim tkinter ist ja, dass es seine eigenen Positionierungsregeln verfolgt, gegen die ich bisher kein Mittel gefunden habe. Die Beispiele im Internet sind immer so einfach. dafür reicht tkinter aus. Was Du "Inputgenerator" nennst ist in meiner Excel-Oberfläche voll drin. Ich bin in der Dropbox angemeldet. Bis wir dies oder jenes benötigen vergeht noch einige Zeit. Albert

Hallo onoio, Wie kommst Du darauf, dass ich sauer bin? Das ist nicht im Geringsten der Fall! Aber nach meiner Beteiligung in Rouletteforen seit 2006, also seit 12 Jahren, bin ich in der Ausdrucksweise direkter und barscher geworden - das stimmt. Eine Menge negativer Erfahrungen stecken dahinter. Die rein fachliche Frage, die ansteht, ist: Schaffst und machst Du die von mir skizzierte Bedieneroberfläche in PHP? Albert

Hallo onoio, obiger Text lässt ziemlich eindeutig darauf schliessen, dass Du Dir die Beiträge #5 bis #7 in https://www.roulette-forum.de/topic/18480-lernfähige-roulettesysteme-ec-summentendenz-learn/?tab=comments#comment-393176 gar nicht richtig angeschaut hast. Das ist eine allgemeine Krankheit in diesem Forum. Die meisten User können nur maximal 5 deutsche Hauptsätze lesen - und diese oft nicht einmal verstehen. Darum sind hier die meisten Beiträge nur kurz - wie Deine Beiträge alle auch. Die Urschleim-Kriterien für eine Bedieneroberfläche, die Du aufzählst, werden von meiner Excel-VBA-Oberfläche, die auf den ersten 13 Zeilen der Cockpit-Tabelle liegt, voll erfüllt. Sonst könnte ich damit gar nicht testen. Und wenn Änderungen/Erweiterungen anstehen, dann sind diese in 10 Minuten getan. Nun zeig' erstmal, dass so etwas auch in PHP geht (- ich nehme stark an, dass es in PHP gut geht -), dann reden wir weiter. Damit alles ganz klar ist, liste ich die notwendigen Oberflächenelemente auf: 1. Ein virtuelles Tableau zum Einklicken von Zahlen. 2. Eine Combobox für die Permfile-Namen in austauschbaren Verzeichnissen. 3.Textfelder für Eingaben und Meldungen. 4. Zahlenfelder für numerische Parameter. 5. Schalter und/oder Optionbuttons für Testvarianten. 7. Ganz wichtig sind die Buttons, mit denen man Funktionen anstösst. 8. Sehr wichtig: eine Anzeige-Tabelle (gegittertes Listenfeld?) für die Sätze und Abrechnungen. Klick mal bitte unter PHP eine solche Oberfläche zusammen und zeige sie hier. Es muss überhaupt kein Inhalt dahinter sein. Du brauchst natürlich Beschriftungen. Die kannst Du aus meinem Beispiel im Posting v. 21.10.2018, 01:19 Uhr übernehmen. Wenn Du ein solches Machwerk in relativ kurzer Zeit zustande bringst, dann steige ich auf PHP um - noch vor dem Umstieg auf Python. Albert

Hallo Ego, 1. den py-Quelltext aus dem vorigen Posting habe ich kopiert und angetestet. Es fängt gut an, die Combobox wird gefüllt, aber nach dem Click auf ein Entry wird die Klasse 'Coup' vermisst, die ja in Deine Version nicht mehr reingehört. Da fehlt ein Import oder die Anweisung muss raus. 2. "Es wird dringend Zeit, eine Ausgabe der gelesenen Permanenz zu erzeugen." Ja, dann mach' mal. Es müsste wohl ein scrollbares Listenobjekt sein, das auch Tupel abbilden kann. (Unter Excel hat man die vielfältigen Dienste der Tabellen mit ihren Zellen zur Hand!) 3. "Daher dürfte es auch weiterhin schwierig sein, mit mir zusammenzuarbeiten, denn ich lasse kein gutes Haar an Dir. Im Gegenzug solltest Du danach trachten, mir alle Haare auszurupfen, derer Du habhaft werden kannst." Wie kann man nur so einen Mist schreiben? Das ist ja fast Newfish-Niveau. Entweder man will Zusammenarbeit, dann aber bitte ohne Vorbehalte. Warum soll da etwas schwierig sein, wenn man die Zusammenarbeit will? Willst Du es künstlich "schwierig" machen? Wahrscheinlich ist dieser blöde Satz ironisch gemeint? Dass man sich gegenseitig die Programmier- und Denkfehler anzeigt und sich dabei immer ehrlich, hilfreich und gut benimmt, das ist doch der einzige Sinn und Zweck der Kooperation. 4. "Dir ist sicherlich klar, dass Dich Steve Jobs für so ein "Interface" öffentlich in Streifen hätte schneiden lassen." Da stimme ich Dir voll zu! Aber vergiss nicht, dass, wie gesagt, unter Excel eine Oberfläche super einfach und schnell zu machen ist, die auch sofort perfekt funktioniert. Wenn ich an das Gewürge mit tkinter denke, wird mir ganz übel. Hattest Du nicht vor einiger Zeit geschrieben, dass "ein User Interface keinen Informationsinhalt hat"? Da stimme ich Dir auch zu! Aber man braucht halt ein GUI, sonst kann man nicht vernünftig testen. Und wichtig ist, dass unser beider Testumgebungen kompatibel sein müssen, sonst können wir keinen Code austauschen! Also tkinter scheidet für mich völlig aus!!! Ich habe mir ja pyQt runtergeladen. Dazu gibt es das gute Tutorial, dessen Link Du hier eingestellt hast. Mir fehlt für ca. 1 Woche die Zeit, um mich damit zu beschäftigen. Ich muss mich um mein neues "EC-BinärFigurenLearn" kümmern und versuchen, damit etwas Kohle zu machen. Mich wundert, dass Du zu dem Lernmodell, das u.a. Deine Gedanken umsetzt, bisher nichts gesagt hast. Dafür ist plötzlich das Sch...tkinter en vogue - versteh' einer die Leute. Kopf hoch und weiter! Albert

Hallo EGO, Ein GUI unter Excel zu machen ist das denkbar Einfachste. Man definiert einen Fixbereich, der nicht scrollbar ist und zieht die Controls aus dem Werkzeugkasten drauf oder man kopiert sie aus einer anderen Excel-Mappe. Excel kreiert auch automatisch für jedes Control die zugehörigen Standard-Callback-Routinen, bzw. deren Hüllen. I.d.R. kann man unter einer großen Vielfalt an Callback-Funktionen auswählen, z.B. MouseUp, MouseDown, Keypress, MouseMove, Click, DblClick etc.. Für Parameter- und Texteingaben nutzt man die Zellen im Fixbereich. Unter dem Fixbereich, im scrollbaren Teil hat man unendlich Platz für Ergebnisausgaben. Die Oberfläche für das Programm "EC-BinärFigurenLearn" sieht ein bisschen wild aus. Was die Controls betrifft, so könnte man die im Design-Modus durch Herumziehen mit der Maus ganz schnell völlig anders strukturieren, ohne dass man an Lokalisierungsparametern herumschrauben muss wie in tkinter und ohne dass man am Code etwas ändern muss. Der Fixbereich umfasst hier die oberen 13 Excel-Zeilen. Das zentrale Steuerelement ist die unscheinbare Combobox links über der 4. Excelzeile. Wenn Du auf die Pooltest-Tabelle in meinem Posting geschaut hättest, dann hättest Du gesehen, dass auch mit Masse egale und mit der d'Alembert grüne Gesamtsalden herauskommen. Die Gefahren der Martingale kenne ich nur allzu gut, aber es gibt keine bessere Alternative. Alle Pooltests in meinen ca. 400 Roulette-Simulationen haben das gezeigt. Ich habe da über die Jahre eine Menge ausprobiert. Das Prognosemodell muss es bringen. Es muss eine solche Trefferdichte erzeugen, dass die MG ohne Zittern anwendbar ist. Meine bisher programmierten Lernverfahren zeigen mir einen deutlichen Silberstreifen am Horizont. Das Konto zeigt es auch. Entscheidend für das klassische Roulettespiel sind die Taktik- und Strategieregeln. Wann setze ich aus, wann steige ich wieder ein, wann setze ich event. ein Paroli, wann überlagere ich, wann höre ich ganz auf oder wechsel den Tisch. Der erfolgreiche Spieler hat solche Regeln verinnerlicht. (Newfish gehört zu dieser Gruppe.) Sie sind ganz schwer zu algorithmieren. Ich habe so etwas noch in keinem Programm drin, bzw. ich habe es mit Selektionen zwischen verschiedenen Märschen versucht, die zu meiner eigenen Verwunderung meist schlechter liefen als die Basismärsche. In den EC-Simulationen ist das Mitführen der Gegenchancen eine sinnvolle taktische Maßnahme. Dass Du Dein 'Herumkrittelnwollen' so in den Vordergrund stellst, finde ich nicht gut. Das machen in diesem Forum doch fast alle. Neugier und Mitmachen wären produktiver. Albert

Hallo EGO, wie es der Zufall will, habe ich mich in den letzten Tagen mit einer neuen Variante des "EC-Figuren-Learn" beschäftigt und kann Deinen Wunsch: "Ich schlage nun zum wiederholten male vor, dass Du Deinen GUI-Vorschlag hier einreichst. Wenn das noch nicht in Python geht, nimm VBA, aber lass uns was sehen." prompt erfüllen. Gut finde ich, dass es eine voll ausprogrammierte Variante des von Dir angedachten Modells ist. Deshalb schau Dir bitte die Beiträge #5 bis #7 in https://www.roulette-forum.de/topic/18480-lernfähige-roulettesysteme-ec-summentendenz-learn/ an. Man kann daran nun eine Menge herumschrauben und neue Varianten in Excel-VBA schnell austesten. Ich erwarte dazu Vorschläge von Dir. Mein Modell arbeitet zunächst Coup für Coup. Wenn man nach Deiner Idee das 2/3-Gesetz reinbringen wollte, müsste man eine flexible Gitterung einführen. Hoffentlich kann ich den Eindruck erwecken, dass man mit Lernverfahren, die auf relativ einfachen Tabellen basieren, dem Zufall auch schon ein Schnippchen schlagen kann. Deshalb würde ich es gut finden, wenn noch ein anderer Programmierer "EC-Figuren-Learn" neu programmieren würde, vielleicht Du in Python, und onio in PHP. Bei der Python-Programmierung mache ich mit - sozusagen als Vorübung für das größere Ding mit KNN. Der Kernalgorithmus sollte eigentlich aus meiner Beschreibung erkennbar sein. In VBA sind es ca. 100 Anweisungen, die nach alter Gutsherrenart nicht objektorientiert geschrieben sind. Ich müsste sie noch voll kommentieren und könnte sie per PN rüberreichen. Auf gute Zusammenarbeit beim Basteln "lernfähiger Roulettesysteme"! Albert

Nein, weder als Kritik, noch als Angriff habe ich es aufgefasst. Persönliche Angriffe kommen von einer anderen Klientel, z.B. von Sachse, starwind, ratzfatz usw. Das sind Leute, die trotz vieler eigener Beiträge (beim Sachsen sind es über 20.000) noch nicht gemerkt haben, wozu das Forum eigentlich da ist. Sie bevorzugen es, über User herzuziehen, statt Roulettesysteme zu diskutieren. Das ist doch nicht schlimm. Woher Deine Abneigung gegenüber GUI's und topdown? Weißt Du nicht, dass Apple vor allem durch GUI-Erfindungen zum Weltkonzern aufgestiegen ist? Das sollten wir beim Python-Deep Learning-Projekt ausprobieren. Auf Grund dieser Deiner Bemerkung vermute ich, dass Du noch nie einen Debugging-Service benutzt hast. Debugging ist gerade unter Excel-VBA eine super Sache. Das ist komplett falsch. Insgesamt schließe ich aus Deinen Argumenten, dass Du noch nie eine vollständige Roulette-Simulation programmiert hast - mit Couptest, Permtest und Massentest. Verstehe das bitte nicht als Kritik oder Angriff. Es geht nur um die Klarstellung. Alle, die z.B. nur mit Excelformeln operieren, sind in der gleichen Lage. Massentests gehen damit nicht, weil man keine Schleifen fahren kann. Ab morgen wird nicht mehr philosophiert, sondern programmiert. Gruß! Albert

Oh je! Bei mir war und ist niemals die Benutzeroberfläche der Schwerpunkt! Sie muss es aber geben, damit man überhaupt ein bisschen Roulette simulieren, dh. irgendein Prognosemodell testen kann. Ich habe Hemmungen, das Selbstverständliche weiter zu erklären. Oh je! So etwas Abstruses habe ich noch nicht gelesen. - trivialer geht es nicht! Na ja, das "Fetzen" gehört zum Geist und Hauptinhalt dieses Forums. Ich muss mich langsam fragen, warum ich mich dem noch aussetze. Ein alter DDR-Spruch: "Es gibt viel zu tun! Lassen wir es sein!" Albert

Hallo onoio, willkommen im Club! Ist Dir klar, dass wir nicht irgendein System programmieren wollen, sondern eine KNN-Anwendung mit Python (KNN = Künstliche Neuronale Netze)? Unter Python gibt es Moduln dafür. Wie schaut's unter PHP damit aus? Albert

Hallo Ego, Deine Mahnung ist berechtigt, und sie freut mich sogar. So kann ich sagen, dass ich momentan partout keine Zeit habe. Ich bin voll mit einem Excel-VBA-Projekt für Newfish beschäftigt. Newfish ist ein toller hochintelligenter Kerl und für uns ein "Hoffnungsträger". Er widerlegt total die Sachse-These, dass klassisch nix geht. Das Newfish-Projekt läuft noch ca. 4 Wochen. Ja genau! Ich habe aber in 12 Jahren niemanden gefunden, der einigermaßen programmieren konnte und im Team agieren wollte. Meine einzige und letzte Hoffnung ruht auf Dir! Ich habe noch 2 "Programmierfreunde". Der eine hat es noch nicht geschafft, einen Pooltest zu codieren. Der zweite kann gut mit der Excel-Formelsprache umgehen und wollte auch VBA lernen. Er hat es aber bisher nicht gerissen, weil er noch voll in einem anspruchsvollen Beruf steht. Wenn wir wollen, geht es ganz einfach: 1. Beide arbeiten am gleichen Projekt. 2. Intensiver Austausch per TeamViewer und Telefon. Gruß! Albert

Lieber Ego, solche Betrachtungen/Untersuchungen sind nützlich, hilfreich und gut. Aber zuerst brauchen wir einen Testrahmen, also eine GUI, die wir gemeinsam nutzen und die - eine Permanenzverwaltung enthält (Perms laden, speichern, anzeigen, Perms und Pools abarbeiten), - mehrere Märsche und deren Trefferverläufe anzeigen kann (- ähnlich wie in Excel: https://www.roulette-forum.de/topic/18480-lernfähige-roulettesysteme-ec-summentendenz-learn/ -), - Schalter und Textfelder für die Steuerung zur Verfügung stellt. Dann können wir reihenweise verschiedene Modelle reinhängen und antesten, z.B. zuerst die Normalisierung der Pleins. Mit tkinter haben wir in der Richtung keine Chance. Ich habe mir pyQt heruntergeladen Habe aber noch keine Zeit zum Üben gehabt. Gruß! Albert

Einen binären Entscheidungsbaum speichert man in einer Entscheidungstabelle. Auf EC angewendet stellen die Zeilen dieser Tabelle EC-Figuren dar. Die Tabellenzeilen können mit einem alphanumerischen Code adressiert werden, der einfach eine Aneinanderreihung der EC-Symbole einer Coupstrecke ist, z.B. "SRRSS" oder "RRRSSS" ist. Man muss die maximale Tiefe des Entscheidungsbaumes (dh. die maximale Figurenlänge) festlegen, bevor die Entscheidungstabelle angelegt wird. Die Baumstruktur wird dadurch abgebildet, dass man der Entscheidungstabelle eine Spalte für die Vorknoten-Nr. gibt. Dann dreht man in der Perm eine Schleife vom aktuellen (Endcoup - Tiefe + 1) To Endcoup und trägt in der Entcheidungstabelle für jeden durchlaufenen Coup den alphanumerischen Key und die Vorknoten-Nr. ein. Ich exerziere das mal für S/R und Baumtiefe 4: In der Spalte "Anz. Fälle" zählt man die aufgetretenen Figuren bei der Analyse der Perms. Anhand der Vorknoteninformation kann man den Baum graphisch reproduzieren und die Fallzahlen an die Endknoten schreiben. Die graphische Baumvisualisierung wird aber nicht gebraucht, wenn man Satzprognosen aus der Entscheidungstabelle ableiten möchte. Die Entscheidungstabelle vergrößert sich bei wachsender Baumtiefe im Stil der Martingale. Die alphanumerische Codierung der Keys hat den Nachteil, dass jeder Zugriff auf die Entscheidungstabelle mit einem Suchlauf verbunden ist Im obigen Beispiel habe ich die Keys sortiert eingetragen. In der Praxis muss das nicht so laufen. Die unsortierte Speicherung verkürzt sogar ein wenig die Suchläufe. Nach meiner Erfahrung kann man die Suchläufe bis zur Baumtiefe 8 sequentiell codieren. Darüber muss man Datenbanktechniken einsetzen. Die Entscheidungstabellen-Technik werde ich demnächst in meinem neuen Programm "EC-SummenTendenz-Learn" anstelle der Lernmatrizen testen. https://www.roulette-forum.de/topic/18480-lernfähige-roulettesysteme-ec-summentendenz-learn/ Sie repräsentieren eine differenziertere Erfassung der EC-Figuren und -Tendenzen. Wohl wahr! Ich teile mit Ego die Hoffnung, dass es mit Python leichter geht, wenn man Python vielleicht innerhalb des nächsten halben Jahres gelernt hat. Albert

Hallo Novice, Der Faktor f*70/100 ist nun geklärt. Aber warum die Multiplikation mit 0,7? Warum die Setzpfeile mitten in einer absteigenden Coupstrecke? Wie soll ich rein aus dem Bild einen Algorithmus erkennen? Was Erklärungen betrifft, bist Du wahrlich nicht der König von Deutschland! Außerdem scheint das System sehr satzarm zu sein. (Eine gewisse begrenzte Satzarmut ist allerdings günstig und wichtig.) Ich ziehe mich von diesem speziellen Thema zurück. Albert

Hallo novice, wie wär's mal mit einem Beispiel? Woher kommt der Wert 70? Was bedeutet der Wert 15? Albert

Hallo Ego, Ich versuche jetzt, nur den Text meines Antwort-Postings loszuwerden: Das hat Gott sei Dank geklappt! Im "Bearbeiten"-Modus gebe ich nun das Bild dazu. Qt ist wirklich ein Lichtstreifen am Horizont! Damit können wir anfangen. Wenn Du schon eine Übung mit dem Qt-Designer durch hast, stelle den Code doch bitte hier ein. Die Frage ist nun, welches System nehmen wir uns zuerst vor? Mein Gedanke war ja, dass wir vor dem Deep Learning Python-übungshalber ein einfaches Lernsystem programmieren sollten. Als Vorlage wollte ich ein "Novice-analoges" EC-System in Excel-VBA erstellen. Du hast das so akzeptiert. Das Programm habe ich in 15 Programmierstunden fertig gemacht. Es hat aber mit dem Novice-Verfahren nichts zu tun. (Man könnte es leicht auf die Novice-Wechsel-Auswertungen umstellen, wenn Novice die mal verständlich erklären würde.) Statt Novices EC-Wechsel verwende ich Deine EC-Summencodierung. Wenn S/G/M mit -1 und R/U/P mit +1 codiert sind, liefert deren Summe über eine bestimmte Teilstrecke eine Zahl, die eine grobe Tendenz anzeigt. Ist die EC-Summe negativ, dann hat auf dieser Teilstrecke S/G/M dominiert. Ist die EC-Summe positiv, dann hat auf dieser Teilstrecke R/U/P dominiert. Mein Programm heisst "EC-SummenTendenz-Learn". Ich werde es in einem eigenen Thread beschreiben. Es scheint ähnlich gut zu funktionieren wie mein "ECS-Figuren-Learn" https://www.roulette-forum.de/topic/18361-lernfähige-roulettesysteme-ecs-figuren-learn-feldzug/?page=2 Grundlage von "EC-SummenTendenz-Learn" sind 3 (Lern-)Matrizen - für jedes EC-Paar eine Matrix. Die Perms werden in Teilstrecken ("CpSegmente") gegittert durchlaufen. Die Längen der CpSegmente sind variabel einstellbar. Als Höchstlänge habe ich 15 festgelegt. Jedes Segment liefert mittels der EC-Summen einen Zahlencode, der zwischen -15 und +15 variiert, wenn die Segmentlänge auf 15 eingestellt ist. Ist die Segmentlänge auf 1 eingestellt, dann variieren die EC-Summen zwischen -1 und +1. Mit den EC-Summen-Codes werden die Zeilen und Spalten der Matrizen addressiert. Zuerst werden in der Lernphase pro Perm die Zähler der Vorgänger-Nachfolger-Segmente in den Matrizen gesammelt. In der anschließenden Kannphase wird für das letzte Segment - das aus der Lernphase ausgeklammert war - die EC-Summe ermittelt. Sie liefert die Einstiegszeile für die Matrizen. Die Zähler in den Matrizenspalten liefern dann die Information, ob in der Perm-Vergangenheit dieses Segments die Minus- (S/G/M) oder Plusseite (R/U/P) dominiert hat. Wie bereits erwähnt, sind die Ergebnisse dieses Verfahrens ermutigent. Es hat aber den Nachteil, dass auf der Bedieneroberfläche 3 Märsche á 4 Spalten benötigt werden. Dazu kommen noch 4 Spalten für einen Selektionsmarsch. Der Trefferverlauf für einen Marsch sieht so aus: Ich muss "EC-SummenTendenz-Learn" auf einen Marsch einkürzen. Dann könnte es eine brauchbare Vorlage für ein Python-Übungsprogramm sein. --------------------------------------------------------------------------------------------------------------------------------- Am 19.9.2018 um 01:04 schrieb Egoist: Aber es ist sicherlich auch denkbar einen VBA-Code automatisch nach Python zu übersetzen. Gruss vom Ego -------------------------------------------------------------------------------------------------------------------------------- Codekonvertierungen IBM-Assembler --> PL/1 und C++ --> Java habe ich schon mal gemacht. Das lohnt sich erst, wenn >= 50 Programme zur Konvertierung anstehen. Wir haben vorerst noch "from Scratch" zu lernen. Gruß! Albert

Hallo Ego, Ich habe ca. 5 Stdn. für ca. 7 Versuche gebraucht, mit einem mittellangen Postings zu antworten. Es kam immer die Meldung "Forbidden". Was tun? Albert

Die Seite ist von meiner Kiste mit Chrome nicht erreichbar. Gibt es andere Layout-Optionen, die man wählen kann? Es ist kein Problem, zu Deiner roulib01.py zurückzukehren. Meine Klasse "Coup" habe nur übungshalber gemacht. So mager, wie sie bisher angelegt ist, braucht man sie nicht. Mir ist klar, dass man sich die EC's zu jeder Zeit aus Deiner Klasse "Roulette-franz()" holen kann, wenn man eine Plein am Wickel hat. Unter Anaconda ist eine "qtconsole" verfügbar. Im zugehörigen Helpfile gibt es keinen Hinweis auf eine GUI mit variablen Widgets. Danke, dass Du diese Vorgehensweise akzeptierst. Wenn es soweit ist, wirst Du sicher bei der Umsetzung in Python helfen. Gruß von Albert

Hier ist der Quelltext: # -*- coding: utf-8 -*- #======================== # imports #======================== #import sys #sys.path.append("D:\Python") #print(sys.path) #import re # Modul für Regular Expressions #import numpy as np #import matplotlib.pyplot as plt #import roulib01 as roulEGO # Unsere eigene Library, sie hat eine neue Versionsnummer. import tkinter as tk from tkinter import ttk import os import roullib00 as roul ChArten = roul.ChancenArten() # Konstruktor, der eine Instanz mit frei wählbarem Namen erzeugt. # globale Strings hinweis01 = ["(Bitte Pfad oben eingeben)"] fehler01 = ["Pfad ist üngültig!"] fehler02 = ["keine Coup-Nr.!"] fehler03 = ["Eingabe ungültig!"] # Erzeuge eine Instanz win = tk.Tk() # Füge einen Titel hinzu win.title("Meine erste GUI") # Enable resizing x-dimension, disable y-dimension win.resizable(True, True) win.geometry('800x300') # Modul-globale Variable #----------------------------- lastcoup = 0 perm = [] couplist = [] # Kopierstrings für das Directory-Eingabefeld: # D:\4All\Roulette\Edgar\Wien_F1_1992 # F:\Roulette\Faustan def ResetPerm(): pass # lastcoup2 = 0 # perm2 = [] # couplist2 = [] # lastcoup = lastcoup2 # perm = perm2 # couplist = couplist2 def read_Directory(path): txtfiles = [] # leere Liste der Dateinamen, wird nur lokal erzeugt! zz = 0 try: # Die Dateinamen einsammeln for filename in os.listdir(path): txtfiles.append(filename) zz = zz + 1 #print(zz) #print(filename) except: print('Not found: Dir=' + path) txtfiles = fehler01 print(str(zz) + ' Permfiles gefunden') return txtfiles # Dateiliste zurückgeben (ist leer für ungültige und leere Pfade). def click_FillCombo(entry): fileliste = read_Directory(dirtext.get()) # ruft Dateiliste für aktuellen dirtext ab combo_1['values'] = fileliste # Die Combobox befüllen combo_1.current(0) def print_filename(): fn = dirtext.get() fn += "\\" fn += combo_1.get() # angeklickte Datei anhängen print(fn) # Anzahl der Perms wird angezeigt # Die Perm mit allem Drum und Dran in die Liste lines einlesen #---------------------------------------------------------------- file = open(fn) lines = file.readlines() print(str(len(lines)) + " Permlines gefunden.") file.close() # Die Listen perm und couplist füllen, dabei die Textzeilen aus lienes abtrennen #--------------------------------------------------------------------------------- x = 0 tx = 0 for each in lines: ti = lines[x].rstrip() # Escapes und Blanks herausnehmen try: i = int(ti) # print(i) perm.append(i) # der perm[]-Vektor wird gefüllt cp = roul.Coup() # eine neue Coup-Instanz # die Attribute aktualisieren cp.pl_nr = i cp.ec_SR = ChArten.ec_RS[i] cp.ec_GU = ChArten.ec_UG[i] cp.ec_MP = ChArten.ec_TH[i] # cp.dc_KO = ChArten.dc_col[i] # cp.dc_DU = ChArten.dc_duz[i] # cp.c6_TVS = ChArten.c6_tvs[i] # cp.c12_TVP = ChArten.c12_tvp[i] # ein paar Testausgaben # print(str(cp.pl_nr) + " " + str(cp.ec_SR) + " " + str(cp.ec_GU)) # nur Testanzeige couplist.append(cp) # die Couptabelle wird gefüllt except: tx += 1 # nichtnumerische Zeilen zählen # print("Textzeile:" + ti) x += 1 sizePerm = len(perm) # Anzahl der Permzahlen # Anzeige der Textzeilen und Permzahlen in label6 label6.configure(text=(str(tx) + " Textzeilen, " + str(sizePerm) + " Permzahlen")) def callback(entry): # universelle Ausgabe, als temporäre Debugfunktion print_filename() lastcoup = roul.Coup.counter print(str(lastcoup) + " Coup-Objekte angelegt") def entry1_return(event): try: i = int(entry1.get()) # if i<0 or i>36: print(i) perm.append(i) # der perm[]-Vektor wird gefüllt cp = roul.Coup() # eine neue Coup-Instanz # die aktuellen Attribute holen cp.pl_nr = i cp.ec_SR = ChArten.ec_RS[i] cp.ec_GU = ChArten.ec_UG[i] cp.ec_MP = ChArten.ec_TH[i] # ein paar Testausgaben print(str(cp.pl_nr) + " " + str(cp.ec_SR) + " " + str(cp.ec_GU)) # nur Testanzeige couplist.append(cp) # die Couptabelle wird gefüllt label6.configure(text=(str(len(perm)) + " Permzahlen")) # neue Perm-Anzahl anzeigen label7.configure(text=(str(i) + " angefügt")) # neue Permzahl anzeigen except: label7.configure(text=fehler03) def entry1_del(event): # entry_delete fand ich, lag zu nah an entry.delete, umbenannt entry1.delete(0, 'end') # Eingabefeld für Permzahlen entry1 = tk.Entry(win, width=6) #win, width=4, textvariable=PZahl) #entry1.bind('<Return>', on_change) entry1.bind("<Escape>", entry1_del) entry1.bind("<Return>", entry1_return) entry1.grid(column=1, row=3) entry1.focus() # Setze den Cursor in die Textbox # Eingabefeld für dirname name = tk.StringVar() dirtext = ttk.Entry(win, width=40, textvariable=name) dirtext.grid(column=2, row=4) dirtext.bind("<Return>", click_FillCombo) # Eine Combobox anlegen # Eine ComboBox hinzufügen combo_1 = ttk.Combobox(win, width=38, values=hinweis01) combo_1.grid(column=2, row=5) combo_1.current(0) combo_1.bind("<<ComboboxSelected>>", callback) # callback als Baustellenschild :) # Textfelder (Labels) hinzufügen #---------------------------------------------------- label1 = ttk.Label(win, text="Enter a Plein-Nr. & Return:") label1.grid(column=0, row=3) #label1.configure(text=fehler01) # 2 Überschriftszeilen label2 = ttk.Label(win, text="* User Interface für Roulette-Tests *") label2.grid(column=1, row=0) label3 = ttk.Label(win, text="*************************************") label3.grid(column=1, row=1) # Labels hinzufügen label4 = ttk.Label(win, text="Click on an entry:") label4.grid(column=1, row=5) # Labels hinzufügen label5 = ttk.Label(win, text="Permpool-Directory:") label5.grid(column=1, row=4) # Labels hinzufügen label6 = ttk.Label(win, width=100, text='Anzeigen') label6.grid(column=3, row=5) # Labels hinzufügen label7 = ttk.Label(win, width=42, text='Next Plein') label7.grid(column=2, row=3) # Buttons hinzufügen #-------------------------------------------------------- action1 = ttk.Button(win, text="Reset Perm", command='') action1.grid(column=1, row=2) #action1.configure(text="NO!") #action1.configure(text="NO!") # Einen 3. Button hinzufügen action2 = ttk.Button(win, text="Permtest von oben", command="") action2.grid(column=1, row=8) # Einen 3. Button hinzufügen action3 = ttk.Button(win, text="Permtest von unten", command="") action3.grid(column=1, row=10) # Einen 5. Button hinzufügen action4 = ttk.Button(win, text="Pooltest", command="") action4.grid(column=1, row=12) #================== # GUI-Start #================== win.mainloop() Gebraucht wird aus Ego's roulib01.py nur eine einzige Tabelle. Die steckt in roullib00.py: # -*- coding: utf-8 -*- """ Created on Thu Jul 12 20:40:55 2018 @author: Anwender """ # Ego's numerische Listen class ChancenArten(): pl_kessel = [0, 32, 15, 19, 4, 21, 2, 25, 17, 34, 6, 27, 13, 36, 11, 30, 8, 23, 10, 5, 24, 16, 33, 1, 20, 14, 31, 9, 22, 18, 29, 7, 28, 12, 35, 3, 26] pl_fach = [0, 23, 6, 35, 4, 19, 10, 31, 16, 27, 18, 14, 33, 12, 25, 2, 21, 8, 29, 3, 24, 5, 28, 17, 20, 7, 36, 11, 32, 30, 15, 26, 1, 22, 9, 34, 13] ec_RS = [0, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, 1, -1, 1] ec_TH = [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1] ec_UG = [0, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1] dc_col = [0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3] dc_duz = [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3] c6_tvs = [0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6] c12_tvp = [0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12, 12] c9_car = [(0, 1, 2, 3), (1, 2, 4, 5), (2, 3, 5, 6), (4, 5, 7, 8), (5, 6, 8, 9), (7, 8, 10, 11), (8, 9, 11, 12), (10, 11, 13, 14), (11, 12, 14, 15), (13, 14, 16, 17), (14, 15, 17, 18), (16, 17, 19, 20), (17, 18, 20, 21), (19, 20, 22, 23), (20, 21, 23, 24), (22, 23, 25, 26), (23, 24, 26, 27), (25, 26, 28, 29), (26, 27, 29, 30), (28, 29, 31, 32), (29, 30, 32, 33), (31, 32, 34, 35), (32, 33, 35, 36)] c18_che = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 4), (2, 3), (2, 5), (3, 6), (4, 5), (4, 7), (5, 6), (5, 8), (6, 9), (7, 8), (7, 10), (8, 9), (8, 11), (9, 12), (10, 11), (10, 13), (11, 12), (11, 14), (12, 15), (13, 14), (13, 16), (14, 15), (14, 17), (15, 18), (16, 17), (16, 19), (17, 18), (17, 20), (18, 21), (19, 20), (19, 22), (20, 21), (20, 23), (21, 24), (22, 23), (22, 25), (23, 24), (23, 26), (24, 27), (25, 26), (25, 28), (26, 27), (26, 29), (27, 30), (28, 29), (28, 31), (29, 30), (29, 32), (30, 33), (31, 32), (31, 34), (32, 33), (32, 35), (33, 36)] format_Farbe = ['\x1b[1;42;30m 0 \x1b[0m', '\x1b[1;41;37m 1 \x1b[0m', '\x1b[1;40;37m 2 \x1b[0m', '\x1b[1;41;37m 3 \x1b[0m', '\x1b[1;40;37m 4 \x1b[0m', '\x1b[1;41;37m 5 \x1b[0m', '\x1b[1;40;37m 6 \x1b[0m', '\x1b[1;41;37m 7 \x1b[0m', '\x1b[1;40;37m 8 \x1b[0m', '\x1b[1;41;37m 9 \x1b[0m', '\x1b[1;40;37m 10 \x1b[0m', '\x1b[1;40;37m 11 \x1b[0m', '\x1b[1;41;37m 12 \x1b[0m', '\x1b[1;40;37m 13 \x1b[0m', '\x1b[1;41;37m 14 \x1b[0m', '\x1b[1;40;37m 15 \x1b[0m', '\x1b[1;41;37m 16 \x1b[0m', '\x1b[1;40;37m 17 \x1b[0m', '\x1b[1;41;37m 18 \x1b[0m', '\x1b[1;41;37m 19 \x1b[0m', '\x1b[1;40;37m 20 \x1b[0m', '\x1b[1;41;37m 21 \x1b[0m', '\x1b[1;40;37m 22 \x1b[0m', '\x1b[1;41;37m 23 \x1b[0m', '\x1b[1;40;37m 24 \x1b[0m', '\x1b[1;41;37m 25 \x1b[0m', '\x1b[1;40;37m 26 \x1b[0m', '\x1b[1;41;37m 27 \x1b[0m', '\x1b[1;40;37m 28 \x1b[0m', '\x1b[1;40;37m 29 \x1b[0m', '\x1b[1;41;37m 30 \x1b[0m', '\x1b[1;40;37m 31 \x1b[0m', '\x1b[1;41;37m 32 \x1b[0m', '\x1b[1;40;37m 33 \x1b[0m', '\x1b[1;41;37m 34 \x1b[0m', '\x1b[1;40;37m 35 \x1b[0m', '\x1b[1;41;37m 36 \x1b[0m'] class Coup: counter = 0 def __init__(self): type(self).counter += 1 pl_nr = 0 ec_SR = 0 ec_GU = 0 ec_MP = 0 # dc_KO = 0 # dc_DU = 0 # c6_TVS = 0 # c12_TVP = 0 @classmethod def AnzahlCoups(): return Coup.counter pass Falls jemand das testen will, dann nach Run genau diese Reihenfolge beachten: - Zuerst einen Dir-Namen ohne Single-oder Doublequotes in das Directoryfeld kopieren und "Enter". - Danach in der Combobox scrollen und ein Entry anklicken. Die Perm ist dann in der Liste "perm" und etwas aufbereitet in der Liste "couplist" für die Verarbeitung bereit. Es gibt noch Macken: Der Button "ResetPerm" ist außer Funktion. Beim Anklicken eines 2., 3. etc. Entrys in der Combobox werden die Pleins addiert. Es gibt halt noch keine "ResetPerm"-Funktion. Albert

Hallo Ego, es hapert mit tkinter an allen Ecken und Enden. Nimm dieses Fenster: Man sieht, das längste Element bestimmt die horizontale Ausrichtung. Da kann man für ein einzelnes Element im Parameter "width=..." eintragen was man will. Das Element selbst wird richtig bedient (Verbreiterung von width=6 auf width =60), aber es wirkt sich auf alle aus: In der Vertikalen gibt es eine ähnliche Macke. Ich habe die row-Parameter für die Buttons "Permtest von oben", "Permtest von unten" und "Pooltest" so eingestellt, dass diese Buttons weiter unten gestreut erscheinen müssten. "Pustekuchen" sagt tkinter und knallt die Buttons immer untereinander. Man kann keine Rahmen setzen. Man hat fast keine Macht über die Positionierung der Anzeigeelemente. Wenn man bedenkt, was dieses Fenster noch zeigen muss: die Satzanweisungen, die Abrechnungen, gestaffelt nach Coup, Perm und Pool, und die Trefferverläufe, dann spüre ich richtig körperliche Bauchschmerzen. In Excel-VBA wäre das alles easy und transparent und - schnell zu machen. Das probiere ich jetzt für ein "novice-analoges" Modell aus und messe die Arbeitszeit. Im Prinzip ist meine primitive tkinter-GUI soweit, dass man ein Modell einbauen könnte: Man kann ein beliebiges Verzeichnis anwählen, dann die darin enthaltenen Permnamen in die Combobox holen (Duisburg, Wien, CC, egal), dann eine Perm auswählen, die man über das Eingabefeld "Enter a Plein" fortsetzen kann. Den Quelltext stelle ich vorsichtshalber in das nächste Posting ein. Albert

Hallo novice, schau Dir mal bitte weitere Charts aus dem Trader-Umfeld an und vergleiche mit Ego's Bildern. Könnte es sein, dass die Roulette-Charts generell flacher sind? Albert

Hallo EGO, Die beiden Quelltexte vom Dienstag 00:58 und 01:04 habe ich übernommen. Nach dem Einsetzen eines eigenen Dateinamens path = 'F:\\Roulette\\Faustan\\Faustan1.txt' lief das Programm auf Anhieb und im spyder- Consolfenster sind die ganzen Listenprints und am Ende die Grafik erschienen - halt wie programmiert. (Die volle Grafik sieht man nur, wenn man scrollt. Mein Snippettool kann nur aktuell sichtbare Bereiche des Bildschirms aufnehmen.) Deinen Code habe ich weitgehend verstanden, und er hilft mir weiter. "import numpy as np" wird bei mir als "unused" markiert. "import re" nutzt Du ja auch noch nicht, wird aber nicht als "unused" markiert. Ich kämpfe noch mit tkinter, das sehr merkwürdige Effekte zeigt. Bis bald! Albert

@novice Es ist gut, dass Du Dich offen von diesem Thema abgemeldet hast. So entstehen für Ego keine falschen Erwartungen, die enttäuscht werden, weil nichts geliefert wird. Gestern ist mir das Buch "Der Schwarze Schwan" von Nassim Nicholas Taleb (ein Ami, im Libanon geboren) in die Finger gekommen und hat mir den ganzen Tag "geraubt", weil ich es nach den ersten Seiten nicht mehr weglegen konnte. Darin ist viel vom Traden und von (unfähigen!) Tradern die Rede. Taleb war selbst Trader. Deshalb empfehle ich es Dir (8,41€ bei Amazon). Schwarze Schwäne sind überraschende Ereignisse, bzw. Umbrüche, die mit den an Gauß orientierten statistischen Methoden nicht vorhersagbar sind, aber oft die Welt mehr verändern als das statistisch bewertete "weiter so" (Beispiele: Börsencrashs, Kriege, 9/11, Ehescheidungen = negative Schwarze Schwäne) Taleb unterscheidet "skalierbare" und "nicht skalierbare" Tätigkeiten und Berufe. Skalierbar ist z.B. die Tätigkeit eines Bäckers. Sein Einkommen ist abhängig von der Menge der Brötchen, die er backt, und er muss für jedes Brötchen annähernd den gleichen Aufwand leisten. In nicht skalierbaren Berufen (Schauspieler, Trader, Schriftsteller, Glücksspieler etc.) gibt es mehr Freiheiten aber auch riesige Unterschiede beim Ertrag. Hier gilt die Regel "The winner takes all", die anderen hungern. Taleb zeigt nun, dass meistens der Erfolg der Winner nicht auf Talent beruht, sondern auf Glück und Zufall (= positive Schwarze Schwäne) - ein Zufall, der nicht berechenbar ist. @Ego Rein theoretisch sind Zweifel angesagt, ob der Roulette-Zufall mit Python besser beherrscht werden kann. Also in den nächsten Tagen versuche ich, ein Programm hinzukriegen, mit dem man testen kann, ob man nach Jason Brownlee höchstens den letzten Satz für die EC-Prognose verwenden kann oder ob Deine Vermutung "I know that the next time step depends on nearly all predecessors." richtig ist. Jason Brownlee heißt der Autor des von mir erwähnten E-Books "Introduction to Time Series Forecasting with Python", Untertitel "How to Prepare Data and Develop Models to Predict the Future". Gruß! Albert