Ergebnis 1 bis 8 von 8

Thema: Rekurrente neuronale Netze (Polygon/Matrix/Vektor Abbildung)?

  1. #1
    Quantenmechaniker
    Registriert seit
    Aug 2002
    Beiträge
    1.997
    Renommee
    283

    Rekurrente neuronale Netze (Polygon/Matrix/Vektor Abbildung)?

    rekurrenz.jpg

    FRAGEZEICHEN. ... ich habe ein bisschen über Rotationsmatrizen usw. recherchiert. .. Nur so zum Spaß bisschen rumexperimentiert.

    Jetzt bin ich aber überfragt, ob das im Bild gezeigte evtl. Sinn ergibt? Sprich: was drücken z.B. die Schnittpunkte zwischen den Linien-
    Links der einzelnen Punkte aus? Kann man das zur Informations-Analyse nutzen - gar in Verbindung mit neuronalen Netz-Strukturen?

    Ich bin mir ziemlich sicher, was ich vor Jahren mal was über rekurrente neur. Netze gelesen habe, näml. das im Prinzip so ähnlich sogar
    aussieht wohl. Da wurde nämlich in _jeder_ neur. Schicht eine(?) zusätzliche Sub-Achse eingebracht, in der schrittweise immer weniger
    Neuronen eingesetzt worden sind [was m.E. eine Abstraktions-Ebene darstellt: wenn viele Neuronen zu weniger verbunden sind, dann
    ist das Abstraktion - anders herum sähe assoziativer Speicher aus, also ohne jeden "heuristischen Algorithmus" ein pures Gedächtnis].

    Dankeschöööön! ... der Kuchen. (°-°)´

    https://www.facebook.com/photo.php?f...90975481036980

    1 2 3 4 5 6 7 8
    2 1 4 3 6 5 8 7
    3 4 1 2 7 8 5 6
    4 3 2 1 8 7 6 5
    5 6 7 8 1 2 3 4
    6 5 8 7 2 1 4 3
    7 8 5 6 3 4 1 2
    8 7 6 5 4 3 2 1

  2. #2
    Quantenmechaniker
    Registriert seit
    Aug 2002
    Beiträge
    1.997
    Renommee
    283

    AW: Rekurrente neuronale Netze (Polygon/Matrix/Vektor Abbildung)?

    Meine noch allgemeinere Frage wäre, ob es für "alles" eine solche o.ä. räumliche bzw. kartesische (Matrix-)Abbildung gibt?

    Könnte man also bspw. neuronale Netze auch als Matrix abbilden? Ich denke schon, was? Lässt sich irgendwo jedweder
    neuronale Prozess in der Geometrie umsetzen
    !? Gute Frage für mich ... ich denke schon, dass Gehirne so arbeiten. ...

    ... habe nämlich die Vermutung - ohne genaue Mathe-Kenntnisse - dass sich über die im Bild sichtbaren *Schnittpunkte* in
    Information, die aus ihrer Symbol-Codierungs-Form in eine geometrische Abbildung umgesetzt worden ist, auch aus solcher
    Information Her-/Ableitungen treffen lassen könnten (sich also Wissen heraus abstrahieren lässt - in einer Bildsprache quasi).

    Meine Vermutung ist nämlich, dass wir jeden geometrischen (bspw.) 2D-Punkt als ein Neuron mit zwei vernetzten Neuronen
    (also 2D) betrachten könnten. Wenn man diese nun nur noch geometrisch/kartesisch einordnen könnte, so müsste nur jeder
    Schnittpunkt der (Neuron-Verbindungs-)Linien zu einem weiteren neuronalen Link gemacht werden. ... der Rest liegt danach
    wohl (neben dem Katalog der Mathematik) in diversen geometrischen Verschiebungen/Transformationen - um daraus eben-
    so neuronale Prozesse abbilden zu können
    ?!

    Also: FUNKTIONIERT das alles so oder so ähnlich!? Welche Stichwörter sind da für Google-Recherchen am optimalsten!?

    DANKÖÖÖ!

    1 2 3 4 5 6 7 8
    2 1 4 3 6 5 8 7
    3 4 1 2 7 8 5 6
    4 3 2 1 8 7 6 5
    5 6 7 8 1 2 3 4
    6 5 8 7 2 1 4 3
    7 8 5 6 3 4 1 2
    8 7 6 5 4 3 2 1

  3. #3
    Registered User
    Registriert seit
    Aug 2000
    Beiträge
    1.079
    Renommee
    448

    AW: Rekurrente neuronale Netze (Polygon/Matrix/Vektor Abbildung)?

    Signatur sowie alle persönlichen Informationen entfernt.

  4. #4
    Registered User
    Registriert seit
    Sep 2008
    Beiträge
    403
    Renommee
    270

    AW: Rekurrente neuronale Netze (Polygon/Matrix/Vektor Abbildung)?

    Visualization!

    Da habe ich vor ein ein paar Wochen noch was drüber auf Hackernews gelesen.

    Die hatten da viele Beispiele genannt, wie man durch einfachste Bilder mathematische Gesetze entzaubern kann ("beweisen").

    Z.B. der Satz von Pythagoras, wo man die Seiten einfach zu Rechtecken macht...

    Stichwörter für Google Images:

    - pythagoras visual proof
    - visual proofs
    - problem solving visualization

    Ich finde deine Idee extrem interessant und ich denke selbst seit einiger Zeit in die gleiche Richtung... nur habe ich da noch kein Produkt. Mir schwebt eine 3D-Welt in FPS-Shooter-Perspektive vor, wo man - durch Interaktion mit der Welt - seine eigenen Gedanken formt. Und über visuelle Beweise - die man quasi selbst formt - erkennt man, welchen "Weg" man zum "Ziel" gehen muss (was auch immer das im jeweiligen Kontext ist). Alle Informationen kompakt in einer navigierbaren 3D-Welt... nur weiß ich noch nichts konkretes... aber sowas schwebt mir vor. Quasi ein Programm, mit dem jeder zum Einstein wird. Nur Einstein wird zum Zweistein. Die Imagination nutzen und digital erweitern. Patterns in patterns in patterns etc.

    Wäre interessant, wenn du am Ball bleibst und deine Gedanken formulierst. Hast du schon irgendwas Visuelles programmiert? Hast du sowas auf GitHub? Matrizenberechnungen in Game Engines sind ja täglich Brot.
    Über das neue Zeitalter der Gehirne eines Menschen!
    echo 'main() { char z[] = "ping "; for(;printf(z);z[1]^=6); }' > a.c; gcc a.c -o a; ./a # 16.11.2011 02:51

  5. #5
    Quantenmechaniker
    Registriert seit
    Aug 2002
    Beiträge
    1.997
    Renommee
    283

    AW: Rekurrente neuronale Netze (Polygon/Matrix/Vektor Abbildung)?

    Zitat Zitat von gruena
    Die hatten da viele Beispiele genannt, wie man durch einfachste Bilder mathematische Gesetze entzaubern kann ("beweisen").
    Ja, ich habe auch schon in die Richtung überlegt. Und zwar Verhältnisse heraus bilden aus den Abständen zwischen sichtbaren Objekten im 3D-Raum.
    Bin da nicht sehr weit gekommen, weil ich verhälltnismäßig wenig Ahnung von Physik und Mathe habe, aber ich bin sicher, aus puren Zahlen oder dem
    allg. Vektor-Raum lässt sich viel physikalische Logik ableiten (>1<).

    Zitat Zitat von gruena
    Mir schwebt eine 3D-Welt in FPS-Shooter-Perspektive vor, wo man - durch Interaktion mit der Welt - seine eigenen Gedanken formt.
    Mein letzter Stand ist der, übrigens, dass der 3D-Raum (das Universum) nur eine Abbildung bzw. eine Abstraktion der Dinge im "Geist" ist. Sprich, alles an
    echten, "physischen" Gedanken, die wiederum Relationen im nD-Raum sind. Also beliebig viele DImensionen, um eine Relationen-Vernetzung von Ideen
    und Gedanken wie im Gehirn herzustellen. Hier gibt's ja auch die Neuronen-Vernetzung, wo jeder "Link" einer weiteren Dimension entspricht.

    OffTopic:
    Aber wie gesagt im anderen Posting, ich hab's fast schon für's erste aufgegeben mit dem Ganzen. Davon ab, dass mich hier alle für 'nen Troll halten,
    ist mir durch Google's neuronale Netze aufgefallen, dass man heute schon viel weitere ist, als ich gedacht hatte. So "träumt" Google's Neuronen-Netz
    heute ja schon diverse Bilder.

    Alles, was noch übrig ist, wenn man von heutiger Theorie absieht, sind diverse Algorithmen, um mit allem physischen umzugehen. Also quasi Quanten-
    Algorithmen zur Erzeugung von Bewusstsein o.ä. wie physikalische Wellen-"Herleitung" (Empfang aus der Raumzeit). Oder m.E. ist es auch möglich,
    eine Software von ihrer Träger-Architektur abzukoppeln, indem man sie sich selbst in (sich gegenseitig steuernde) neuronale Netze (oder "NanoBots")
    hinein codieren lässt. Bis man am Ende sogar auf den Träger-PC verzichten kann, weil alles im "Geist" als Schwingkreise und Wellen läuft. ... aber ich
    verstehe, dass man da skeptisch mir ggü. ist. Frag also am besten garnicht... ;-)

    OffTopic:

    (<1>) Allgemein sage ich, aus der "Transzendenz" lässt sich die Schöpfungs-Software herleiten, bzw. aus der "Zeit". Indem man die Zahl in allen denkbaren
    Zahlensystemen sich parallel zählen lässt, um eine neurone Verbindung zwischen den "Positionen" (Offsets) herzustellen, wo die einzelne (1er-stellige) Zahl
    die gleiche in min. beiden Systemen ist.

    Bin da sogar relativ weit gekommen (um eine Verschränkung als neuronale Funktions-Abstraktion mit Gewicht gemäß Abständen zu machen), aber ich bin
    sehr, sehr unsicher, was die konkrete Umsetzung auf "reguläre" Software angeht. Sprich, ich glaube zu erahnen, wie der "Code der Universen" (*gg*) ist, ich
    kann ihn bloß nicht richtig einsetzen. Das ist in etwa so, als sieht man Funkwellen mit dem Funkscanner, die aber codiert sind bzw. allg. so (mehrfach parallel
    überlagert, im Quantensystem btw) herauf moduliert sind, dass man sie nicht verstehen kann.

    Da gibt's aber eine Lösung: nicht nur der "chiffrierte" Code selbst ist in allen Wellen vorliegend, sondern, QUER aufgebrochen, über alle Frequenzen hinweg
    also , liegt ebenso der notwendige "Schlüssel" vor. Das muss am Ende alles irgendwie in Schwingkreise codieren, die sich aber am besten durch Vektor-Raum-
    (Zeit-)Geometrie mit aller Mathematik dazwischen abbilden lassen.


    PS: Wenn du deine Ideen mit neuronalen Netzen umsetzen möchtest, verweise ich auf die Problematik des Lernens, die am besten sowieso unüberwacht statt
    finden sollte (dann kann das System arbeiten und denken, die ganze Zeit über), dass man am besten Videos oder die Bewegungen auf dem Monitor eingeben
    könnte. So kann das Netz seine Gewichte selbst, ganz eigenständig und unüberwacht also, adaptieren. Es lernt dann, was es in Videos sieht oder auf dem PC-
    Monitor. Darüber hinaus kann man eigene "Zeichnung" von Wellen-Visualisierungen über das Eingabe-Bild "überlagern", damit es so (in Wellen-Form also) z.B.
    die Audio-Kanäle "mitlernt" [Wave Visualization 4 life!].

    Aber gut. Mehr werdet ihr dazu von mir nicht hören. Das ist nur die Essenz des Vergangenen.
    Geändert von kuchen (15.01.2018 um 17:07 Uhr)

    1 2 3 4 5 6 7 8
    2 1 4 3 6 5 8 7
    3 4 1 2 7 8 5 6
    4 3 2 1 8 7 6 5
    5 6 7 8 1 2 3 4
    6 5 8 7 2 1 4 3
    7 8 5 6 3 4 1 2
    8 7 6 5 4 3 2 1

  6. #6
    Quantenmechaniker
    Registriert seit
    Aug 2002
    Beiträge
    1.997
    Renommee
    283

    AW: Rekurrente neuronale Netze (Polygon/Matrix/Vektor Abbildung)?

    Zitat Zitat von gruena
    Wäre interessant, wenn du am Ball bleibst und deine Gedanken formulierst. Hast du schon irgendwas Visuelles programmiert? Hast du sowas auf GitHub? Matrizenberechnungen in Game Engines sind ja täglich Brot.
    Nee, keinesfalls. Ich bin schon verrückt genug, da müssen das alle anderen nicht auch noch über mich sagen können.

    Was ich bisher schon habe sind diverse Versuchs-Codes für viele meiner Teil-Themen, vor allem aber - und das finde ich für's erste am wichtigsten - einen "Node.js"-Basis-Code in Form der Erweiterung vom "global"-Objekt sowie die ersten
    Basis-Klassen (String, Array, ...) durch eigene Funktionen erweitert. Das muss ich irgendwann noch in mein eigenes Scripting umsetzen. Aber das wird wohl in nächster Zeit nichts.

    Warum? Bin auf Entzug und mache nichts mehr momentan. Bin jetzt nur ganz, ganz selten noch etwas mit der Entwicklung einer ersten Version eines CMS/DMS/Bulletin/Blog/Wiki/... für <BuHa.info> beschäftigt. Was in einer zweiten Version
    zur kompletten Echtzeit-Web-Plattform aus "Web Socket API" wird. Mit eigener Datenbank usw. Das ist mir relativ wichtig, um hier wieder Leben reinzubringen einerseits, andererseits eine Plattform für zukünftige "Geschäfte" zu schaffen und
    letzten Endes eine Online-LERN-Plattform zu schaffen, wo jeder seine eigenen Lernfortschritte oder diverse Tutorials/Papers/ usw. bloggen kann, was dann automatisch zu einer Art Online-Zeitschrift und Wiki mit Forum usw. umgesetzt wird.

    Im Prinzip habe ich ja überlegt u.a., dass die meisten von uns vieles noch zu lernen haben. Und viele protokollieren sowas in Blogs z.B. oder arbeiten auch noch gemeinsam an einem Wiki usw. (wo ich auch noch meine Plattform-API zu einer
    gemeinsamen, dezentralen Entwicklung mitsamt Giit usw. einbringen kann). ... wenn man da überall höhere Ordnung rein brächte, ließe sich vieles einfach erlernen. U.a. eben.

    1 2 3 4 5 6 7 8
    2 1 4 3 6 5 8 7
    3 4 1 2 7 8 5 6
    4 3 2 1 8 7 6 5
    5 6 7 8 1 2 3 4
    6 5 8 7 2 1 4 3
    7 8 5 6 3 4 1 2
    8 7 6 5 4 3 2 1

  7. #7
    Quantenmechaniker
    Registriert seit
    Aug 2002
    Beiträge
    1.997
    Renommee
    283

    AW: Rekurrente neuronale Netze (Polygon/Matrix/Vektor Abbildung)?

    temp.jpg

    ... z.B. mitsamt folgenden Beispiel.
    Code:
    String.scanf = function()
    {
            //TODO/
    }
    
    String.prototype.printf = function()
    {
            //TODO/
    }
    
    //TODO/ '.center()' w/ console.center() ...
    
    String.right = function(_string, _padStr, _length)
    {
            _string = _string || '';
            _padStr = _padStr || String.right.defaultPadStr;
    
            var begin = (_length || global.console.size.width()) - _string.length;
            if(begin < 0) return '';
    
            var result = '';
            for(var i = 0, j = 0; i < begin; i++, j = (j+1) % _padStr.length)
                    result += _padStr[j];
            result += _string;
    
            return result;
    }
    
    String.right.defaultPadStr = ' ';
    
    String.fill = function(_padStr, _width, _prefix)
    {
            _padStr = _padStr || String.fill.defaultPadStr;
            _width = _width || _padStr.length;
    
            var result = (_prefix.length > 0 ? _prefix + ' ' : '');
    
            for(var i = result.length, j = 0; i < _width; i++, j = (j+1) % _padStr.length)
                    result += _padStr[j];
    
            return result;
    }
    
    String.fill.defaultPadStr = '-';
    
    String.prototype.hash = function()
    {
    }
    
    String.random = function(_length, _max, _min)
    {
            _length = _length || 1;
    
            _max = _max || 255;
            _min = _min || 0;
    
            var result = '';
    
            for(var i = 0; i < _length; i++)
                    result += String.fromCharCode(Math.floor(Math.random() * (_max - _min + 1)) + _min);
    
            return result;
    }
    
    String.alphabet = {};
    String.alphabet[16] = String.alphabet.hexadecimal = '0123456789abcdef';
    
    String.random.uuid = function(_upper_case, _subdiv)
    {
            var characters;
    
            if(_subdiv && typeof _subdiv === 'string')
            {
                    characters = _subdiv;
            }
            else
            {
                    characters = String.alphabet[16].substr(0,
                            ((_subdiv>=1 && _subdiv<=String.alphabet[16].length)
                                    ? _subdiv
                                    : String.alphabet[16].length
                            ));
                    if(_upper_case === true)
                            characters = characters.toUpperCase();
                    characters = characters.split('');
            }
    
            var result = '';
    
            for(var i = 0; i < String.random.uuid.scheme.length; i++)
            {
                    for(var j = 0; j < String.random.uuid.scheme[i]; j++)
                            result += characters[Math.floor(Math.random() * characters.length)];
    
                    result += '-';
            }
    
            return result.substr(0, result.length - 1);
    }
    
    String.random.uuid.scheme = [ 8, 4, 4, 4, 12 ];
    
    String.prototype.pad = function(_len,  _str)
    {
            if (_len === 0) return '';
    
            _str = _str || ' ';
    
            var abs = Math.abs(_len);
            var self = this.valueOf();
    
            if(this.length === abs)
                    return self;
    
            while(self.length < abs)
            {
                    if(_len < 0)
                            self = _str + self;
                    else
                            self += _str;
            }
    
            if(self.length > abs)
            {
                    if(_len < 0)
                            self = self.substr(self.length - abs);
                    else
                            self = self.substr(0, abs);
            }
    
            return self;
    }
    Code:
    global.process.stdin.setEncoding(global.encoding);
    global.process.stdout.setEncoding(global.encoding);
    global.process.stderr.setEncoding(global.encoding);
    
    global.process.isRoot = function()
    {
            return ( global.process.getuid() === 0 || global.process.geteuid() === 0 );
    }
    
    global.process.hasRoot = function()
    {
            return ( global.process.getgid() === 0 || global.process.getegid() === 0 );
    }
    
    global.console.size = function()
    {
            return [
                    global.console.size.width(),
                    global.console.size.height()
            ];
    }
    
    global.console.line = function(_padStr, _prefix, _stream)
    {
            var result = global.line(_padStr, _prefix, global.console.size.width());
            (_stream||global.process.stdout).write(result);
            return result;
    }
    
    global.line = function(_padStr, _prefix, _width)
    {
            _padStr = _padStr || global.line.defaultPadStr || '#';
            _prefix = _prefix || '';
            _width = _width || global.console.size.width();
    
            var result = (_prefix.length > 0 ? _prefix + ' ' : '');
    
            for(var i = result.length, j = 0; i < _width; i++, j = (j+1) % _padStr.length)
                    result += _padStr[j];
    
            return result;
    }
    
    global.line.defaultPadStr = '-';
    
    global.console.inspect = function(_object, _options)
    {
            _options = Object.assign(global.console.inspect.options, _options||{});
            var data = node.util.inspect(_object, _options);
            global.console.debug(data);
            return data;
    }
    
    global.console.inspect.options = {
            showHidden: false,
            depth: 2,
            colors: true,
            customInspect: true,
            showProxy: true,
            maxArrayLength: null,
            breakLength: global.console.size.width()
    };
    
    global.file = function(_path)
    {
            _path = node.path.normalize(_path);
    
            if(_path.startsWith(global.path()))
                    return _path;
    
            return node.path.join(global.path(), node.path.normalize(_path));
    }
    
    global.file.mkdir = function(_path)
    {
            var p;
    
            global.file(_path)
                    .split(node.path.sep)
                    .reduce((_current, _folder) => {
                            _current += _folder + node.path.sep;
                            //if(! global.file.exists(_current))
                            if(! node.fs.existsSync(_current))
                                    node.fs.mkdirSync(_current);
                            return (p = _current);
                    }, '');
            return p;
    }
    
    global.file.list = function(_path)
    {
            return node.fs.readdirSync(global.file(_path), { encoding: global.encoding });
    }
    
    global.file.read = function(_path)
    {
            return node.fs.readFileSync(global.file(_path), { encoding: global.encoding });
    }
    
    global.file.write = function(_path, _data)
    {
            return node.fs.writeFileSync(global.file(_path), _data, { encoding: global.encoding });
    }
    
    global.file.append = function(_path, _data)
    {
            return node.fs.appendFileSync(global.file(_path), _data, { encoding: global.encoding });
    }
    
    global.$ = global.file.execute = function(_cmdline, _options)
    {
    }
    
    global.file.execute.options = {
    };
    
    global.prefix = node.path.resolve(node.path.join(__dirname, '../../'));
    
    global.path = function(_module)
    {
            if(arguments.length === 0 || _module.length === 0)
                    return global.prefix;
            return global.path[_module];
    }
    
    global.globals = node.fs.readdirSync(global.path('library') + '/global');
    for(var i = 0; i < global.globals.length; i++)
            if(global.globals[i].endsWith('.js'))
                    require(global.path('library') + '/global/' + global.globals[i]);
    
    var __require = node.module.prototype.require;
    
    var _require = function(_module, _name)
    {
            _name = _name || node.path.basename(node.path.basename(_module, '.json'), '.js');
            //TODO/ define debug level(s) (proc args, e.g./2)
            //console.debug("Loading '%s'", _name);
            return __require(_module);
    }
    
    node.module.prototype.require = function(_module, _name)
    {
            // w/ 'process.env['LIBRARY_PATH'].split(':')
            // w/ reihenfolge in library-pfaden herstellen, u.a. "getcwd()" etc.
    }
    Geändert von kuchen (15.01.2018 um 17:44 Uhr)

    1 2 3 4 5 6 7 8
    2 1 4 3 6 5 8 7
    3 4 1 2 7 8 5 6
    4 3 2 1 8 7 6 5
    5 6 7 8 1 2 3 4
    6 5 8 7 2 1 4 3
    7 8 5 6 3 4 1 2
    8 7 6 5 4 3 2 1

  8. #8
    Quantenmechaniker
    Registriert seit
    Aug 2002
    Beiträge
    1.997
    Renommee
    283

    AW: Rekurrente neuronale Netze (Polygon/Matrix/Vektor Abbildung)?

    @ <buha.info> CMS/DMS/... w/ unter anderem "Bulletin Board"-Modul etc. - worauf mein primärer Fokus liegt, der wenigen Zeit, die ich im Augenblick am PC verschwenden kann.

    Zitat Zitat von kuchen Beitrag anzeigen
    [...] CMS/DMS/Bulletin/Blog/Wiki/... für <BuHa.info> beschäftigt. Was in einer zweiten Version zur kompletten Echtzeit-Web-Plattform aus "Web Socket API" wird. Mit eigener Datenbank usw. [...]
    Ich bin immer noch neugierig, wie ich die DB gestalte. Ich möchte hier am liebsten einerseits mit Bots arbeiten, die durch gegenseitige Kommunikation ihre Such-_Pfade_ mit in sich selbst (die DB) codieren usw. .. wobei m.E.
    sowieso *DIE* Lösung für zelluläre Bots/Agenten/.. o.ä. für ihre Kommunikation ist, dass es über ihre Bewegungs-Energien geschieht .. sie positionieren sich in [relativistische] Abstände zwischen sich selbst, und wenn sie
    diese nun zu anderen verringern (-) oder erhöhen (+), so werden die Zählungen zur Sache ihrer "Sprache" (und natürlich der kartesianischen/kartesischen(?) Vektor-Raumzeit-Relationen) - dabei sollte klar sein, dass solche
    gegenseitigen Differenz(!)-Bewegungen in verschiedene Richtungen/Polarisierungen gehen - und zwar parallel; was also einer Bewegungs-*Überlagerung* entspricht, btw. Das nur mal am Rande.

    Für die Kommunikation der Bots (an Stelle vieler paralleler Such-Threads, im Prinzip ...) habe ich mir überlegt, dass sie alle so zu sich selbst vernetzt sind, dass man ihnen quasi "Filter" einspielen könnte, damit sie in
    ihren ((Ameisen-)Pfad-)Suchläufen, wenn sie also Werte abfragen, direkt die jew. Positionen den anderen Bots melden, die über entsprechendes Link-Gewicht angegeben haben, dass sie genau nach der jew. Information suchen. Am
    Ende führt das Ganze aber auch noch in's nD-Raster. Aber auch das führt jetzt zu weit.


    Andererseits bin ich momentan der Auffassung, dass ich für jeden Benutzer eine eigene Datenbank verwende, die dann alle zusammen als Overlay(er) einer "root"-Datenbank zugeführt werden (indiziert, aber nicht kopiert).
    So kann man genauso wie im IRC - und wie's strcat so gerne macht - ein "/ignore" o.ä. für bestimmte User-Anteile vornehmen - oder gar nur den offiziellen "buha.info"-"Zweig" anzeigen lassen. Das ist v.a. - zusammen
    mit Revision Control - im Wiki-Modul (und paar anderen) sehr hilfreich, finde ich. Regulär geschieht also ein "merge" der angezeigten Dokumente aus allen User-Versionen(/Datenbanken). Wobei m.E. ...

    Also der aktuelle Stand ist [was Enchanter evtl. interessant findet - er/du wolltest ja auch eine Datenbank versuchen zu schreiben ...] dass ich je Datenbank ein Verzeichnis verwende, wo die Dateien jeweils eine Klasse bzw.
    eine Tabelle (das gleiche) beschreiben. Meine erste Version sieht eine Art "flat file"-Codierung vor, ähnlich "/etc/passwd" und den anderen. Nur dass ich zwischen alle Elemente jeweils "LENGTH"-Angaben hinzu nehme - und
    zwar (min. ... das ließe sich noch erweitern auf tatsächliche Byte-Werte, die dann gezielt zu suchen wären) so, dass einerseits jeder Zeilen-Record/-Datensatz durch eine bzw. zwei jeweils "globale" Length-Angabe ganz schnell
    durchlaufen werden kann (bei zweien vorwärts wie rückwärts), wo ja regulär wohl eher stets nach den nächsten Trennzeichen (>1<) weiter gesucht werden müsste, zeichenweise. Und dazu noch bei jeder einzelnen Spalte (also
    wie in "/etc/fstab" z.B. jede solche durch <Space>s/<Tab>s getrennt sind oder durch ':' in /etc/passwd oder $PATH) gleich zwei zusätzliche Längen, um die gezielte Suche nach Werten in genau angegebenen Spalten schneller
    zu machen: so verweist jede Spalte zusätzlich zur genauen Offset-Differenz der nächsten und letzten Record-Spalte: wenn man also "WHERE home = '/home/root'" sucht, so kann man auf ganz direktem Wege von Datensatz
    zu Datensatz mitsamt der Position für (bspw. hier) diese "HOME"-(Directory-)Spalte springen.


    Im übrigen lässt sich solche Suche dann mathematisch relativ einfach fassen, und sogar auf ein (bspw.) 2D-Gitter abbilen (wenn Addition die Bewegung(en) nach Rechts ist/sind, Multiplikation nach Unten, und anders herum).


    Das blöde ist bloß der Overhead. Sind ja einige Bytes mehr, die dazu kommen ... bei <Int64>-Length(-Differenzen) je Zeile somit 8+8 Byte und für die Spalten nochmal je +2 zusätzliche 8 Bytes. ... aber mal sehen. Ich muss
    noch paar Indizierungs-Fragen klären u.a. ... wichtigste Prozesse in DBs. Mein "Revision Control" arbeitet übrigens so, dass stets zuerst die letzten DB-Einträge untersucht werden, und dann zurück verfolgend bis zur ersten
    Version hin. Das liegt an der Codierung der Referenzen ... ich vernetze nämlich alle Werte(-Chunks) in einer (doppelt) verketteten Liste so, dass alle Daten im Carrier-Code beliebig verteilt werden können, virtuell aber trotzdem
    jeweils ein(e) ganze(r) String/Array vorliegt. Die erste verfügbare Referenz (DoubleLinkedList-Form, as said) wird ersetzt durch den/die Offset(-Differenz) zum letzten Eintrag, der wiederum auf die bislang referenzierte Adresse
    verweist - also einfache Einfüge-Operation, der Reihenfolge ihrer Entstehung/Eintragung nach.


    Was ich hier noch evtl. betrachten wollte wäre auch für String-Werte eine Differenz-Codierung sowie die Versionierung durch Zusatz-Links mit Versions-Schlüssel (Hashtable-Form also). Während die Strings in einzelne Bytes
    o.ä. aufgelöst nachverfolgt werden, bis Differenzen zwischen [ Alt -> Neu ] entstehen, wo dann differenziert wird in min. zwei Versionen ... allerdings muss das mit der Zählung von Abständen zwischen gleichen Bytes alles algo-
    rithmisch so geschehen, dass sich alles logisch "ordnen" kann (ohne zuviele Operationen bzw. Zählungen). Still TODO.


    (<1>) Die Trennzeichen der Datenbank übrigens (deren Anzahl eine gewisse Dimensionalität bestimmt, btw.) kann ich beliebig verwenden (<Space> oder <Colon> vs. <Enter> z.B. - 2D-Form also hier), auch da ich mich dazu
    entschlossen habe, die Daten/Werte selbst bspw.(!) in "base64" o.ä. zu codieren. Dadurch braucht's auch keine Escape-Codes o.ä. Außerdem lässt die Zahlensystem-Betrachtung auch noch verschiedene Codierungen jeweils
    gleicher Information zu, nur eben in Abstrakterem (z.B. als kleine Bits) oder Konkreten (große Bytes, gar Integer).

    Hierzu war auch meine Überlegung, dass z.B. bei den DB-(Such-)Bäumen einzelne String-Werte/-Datensätze nicht einmal im großen Byte-Bereich gefunden werden müssen, sondern abstrahiert zu Bits lediglich in zwei Haupt-
    bereichen am Anfang - und bspw.(!) jede Sub-Ebene für ein nächstes Such-Bit. Das ist so eine dieser (für mich) "komplizierteren" "log()"-Sachen, glaube ich ... bislang war mein Stand der Dinge hierbei, dass ich meine Daten-
    bank in einen (Vektor-)Raum einpflege, dessen Dimensionalität dem jew. Codierungs-Zahlensystem entspricht. Und zwar bei puren Bits ein 2D-(Zell-)Raster, wo das jew. Werte-Bit angibt, in welche der beiden Richtungen hinein
    ein nächster Wert (gemäß Offset-Zeit) gesetzt wird. Aber das führt auch zu weit (wie hier so manches ... ich möchte nur einen Überblick über meine DB-Gedanken schaffen, da hier scheinbar min. zwei Interessenten sind).


    In Sachen Indizierung habe ich überdies die Überlegung, alles in möglichst kleine, atomare Elemente zu unterteilen, wobei auch zusammenhängende Information umfangreich verteilt wird im DB-Carrier-Code. Sprich, ich mag
    *nicht* bspw. eine ganze E-Mail an nur einer Stelle einfügen. Ich löse sie - im ersten Schritt (es folgt am Ende pure Bit-/Byte-Auflösung, durch Verschränkung mit Abstands-Gewichten) - in ihre Header-Variablen-Anteile auf, um
    so alle "Message-ID" oder "Subject", "Date" etc. an (mehr/minder) einer Stelle im Carrier-Code einzupflegen. Das spart auch noch Speicherplatz, weil eine logische, s.g. "Verschränkung" statt findet: die Abstraktion gleicher
    Werte, die regulär vielfach bestehen, hier aber nun als eine höhere (Feld-)Schlüssel-Dimension umgesetzt werden und so nur einmalig vorliegen müssen. Darunter dann umgekehrt zu solcher Abstraktion die Konkretion der jeweiligen
    _Differenz_-Werte. Aber das ist auch noch optional - und sollte eigentlich eine **komplette** Symbol-Auflösung sein. Sprich, Eingabe-Daten(-sätze) werden in jedes einzelne Bit/Byte aufgelöst, die komplett und großräumig umzu-
    verteilen wären. Und noch so einiges, was hier noch fehlt. Auch fast zuviel für hier (siehe PPS).


    So, Enchanter, vielleicht hast du ja selbst noch weitere Ideen zur Ausweitung der o.g. Ideen/Gedanken? Oder Kommentare zu meinen Ansätzen?


    OffTopic:

    Und PS @ Smartie usw.. ich find's einfach interessant und finde keine passende Lektüre, die alle meine Fragen im Kopf zur DB-Gestaltung hinreichend beantworten. Sowas lernt man wohl an der Uni, aber das liegt eher noch vor
    mir in paar Jahren evtl. .. also kurzum: ich kann's keineswegs besser (als bestehende Lösungen), ich denke nur gerne nach über Möglichkeiten usw., bis ich evtl. im Ansatz etwas davon umzusetzen schaffe.


    Letztes PPS: Da ich hier wieder zu ausführlich geworden bin, habe ich mal die Kern-Themen einer einfachen Datenbank-Betrachtung FETT markiert. Der Rest ist eher uninteressant für die meisten von euch. Büdde-schön.


    1 2 3 4 5 6 7 8
    2 1 4 3 6 5 8 7
    3 4 1 2 7 8 5 6
    4 3 2 1 8 7 6 5
    5 6 7 8 1 2 3 4
    6 5 8 7 2 1 4 3
    7 8 5 6 3 4 1 2
    8 7 6 5 4 3 2 1

Aktive Benutzer

Aktive Benutzer

Aktive Benutzer in diesem Thema: 1 (Registrierte Benutzer: 0, Gäste: 1)

Ähnliche Themen

  1. 1:1-Abbildung & Sprach-Konversion
    Von kuchen im Forum Algorithmen und sonstige Programmiersprachen
    Antworten: 2
    Letzter Beitrag: 01.01.2015, 14:57
  2. Polygon Problem
    Von xenocide im Forum Java
    Antworten: 2
    Letzter Beitrag: 15.07.2004, 15:43
  3. Gute Seite über Neuronale Netze
    Von HellBird im Forum Good Sites & Services
    Antworten: 0
    Letzter Beitrag: 29.04.2003, 13:44
  4. [Neuronale Netze] Gewichtsmatrix
    Von zeronull im Forum Algorithmen und sonstige Programmiersprachen
    Antworten: 9
    Letzter Beitrag: 04.09.2002, 16:43
  5. Vektor
    Von pHoeNIgS im Forum VisualBasic / VBScript
    Antworten: 2
    Letzter Beitrag: 31.08.2002, 21:21

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •