Künstliche Intelligenz

nocheinPoet schrieb:Gibt genug Videos inzwischen dazu im Netz, die DeepSeek R1 ohne Quantisierung so laufen lassen. Geht sogar auf einen "normalem" Windows PC, man braucht dazu drei SSD und legt auf jeder eben 200 GB Auslagerungsdatei an, in Summe also 600 GB und natürlich sollte man so viel RAM wie es geht auch so noch in der Kiste stecken haben.

Hab jetzt ebenfalls ein Guide gefunden. Am Ende heißt es, das die Performance "Absolutely Horrible" ist. Wenn das, dass ist, auf das du 2000 Euro drauf werfen willst, klar 😀.

nocheinPoet schrieb:Ganz sicher braucht man kein Rechenzentrum

Wir reden hier über ein Leistung, die für den professionellen Bereich ausgeschlossen ist.

nocheinPoet schrieb:ohne Quantisierung so laufen lassen

nocheinPoet schrieb:Wenn man das ganze Paket will, muss man das ganze Paket nehmen, man kann ja einen Freund besuchen, der in der Stadt wohnt und sehr gut ans Internet angebunden ist, der kann das dann schon mal runterladen, ...

Natürlich. Aber bei Hugging-Face bekommst du dieses Paket. So wie es der Entwickler eben zur Verfügung stellt. Das ist das Original. Wobei, diese Version quantisiert ist (Q8_0) da darfst du dir mal eben über 700 GB ziehn. Bei der Version ohne Quantisierung, also die fp16-Variante, kannst du dir 1300 GB gönnen. Das, was du mit 480G meinst, dürfte die Q4_K Variante sein. Da geht man schon einen Kompromiss ein. Besser, hab ich mir sagen lassen, ist ein Quantisierung von 5 oder 6.

Zu deinem Problem: du könntest deinen sehr guten Freund bitten, das er dir über Ollama das gewünschte Modell herunter lädt. Das kannst du dann Kopieren. Vermutlich gibt es auch einen Befehl für Hugging-Face, damit du nicht alle 163 Dateien anklicken musst, keine Ahnung. Lass mich aber gerne wissen, woher du diese "eine Datei" herunter geladen hast 😀.

nocheinPoet schrieb:Nun ja, die Frage ist, was man wie macht, will man es im VRAM einer Grafikkarte halten und da laufen lassen, oder über die CPU, so große Modelle auf Grafikkarten laufen zu lassen, ist sehr teuer, aber man kann es auch über die CPU machen und hier gibt es llama.cpp.

Ums nochmal klar zu machen. Generative KI alleine über die CPU zu betreiben, das muss man wirklich wollen. Mir machts keinen Spaß.

Tipp: nehm die 2000 Euro und kauf dir eine 5090, am besten noch einige Wochen warten, damit die Beta-Phase abgeschlossen ist.
https://www.heise.de/news/GeForce-RTX-5090-Einzelne-Berichte-ueber-schmelzende-Stecker-10276748.html

Nemon schrieb:Sinnvoll wäre es, Unterstützung zu bekommen bei der Recherche, also eine intelligente Suchmaschine, die auch nach gegebenen Kriterien bewerten, auswerten und zusammenfassen kann. Und dann gleich auch übersetzen.
Zum Beispiel verbringe ich unfassbar viel Zeit damit, geeignete Studien zu finden, denen im ersten Check auf den Grund zu gehen, woraufhin dann die wiss. Diskussion sich anschließt, wenn man sich darauf einlässt. Dann gibt es das Problem der Bezahlsperren. Da müsste man durchkommen. Quellen prüfen wäre auch so eine Sache.

Eine ähnliche Aufgabenstellung sind Fachartikel zu komplexen Themen, bspw. den aktuellen Stand einer technischen Angelegenheit oder die Zusammenfassung einer Experten-Debatte.

Das ist genau dein Thema:

Deep Research Vergleich: Bachelorarbeit in 7 Minuten

Externer Inhalt
Durch das Abspielen werden Daten an Youtube übermittelt und ggf. Cookies gesetzt.

Deep Research gibt aber noch nicht als Open-Source. Bei OpenAI kann man zwar einen Privacy-Mode aktivieren, da muss man dem Ganzen aber erst vertrauen 😀 ...

Ich hatte vor einigen Tagen in einem anderen Thread ein GlowScript-Programm vorgestellt, das DeepSeek R1 ausgehend von einem einzigen Satz erzeugt hatte. GlowScript ist eine Python-Variante, die speziell für im Webbrowser lauffähige 3D-Animationen ausgelegt ist. GlowScript hat einerseits den Vorteil, eine sehr ausdrucksstarke Programmiersprache zu sein (d.h. man kann mit relativ wenig Sourcecode relativ viel Funktionalität beschreiben), aber andererseits den Nachteil, dass man zunächst die GlowScript-Entwicklungsumgebung im Webbrowser laden muss, um GlowScript-Programme laufen zu lassen. Die Einzelheiten hatte ich vor Längerem mal in diesem Beitrag zum Thema Umlaufbahnen (noch mit einem altmodisch selbst geschriebenen GlowScript-Programm ;)) erläutert.

Da es auch eine Reihe von JavaScript-Frameworks (z.B. three.js) gibt, mit denen solche Animationen direkt als html-Datei -- ohne den Umweg über eine andere Programmiersprache -- erzeugt werden können, habe ich DeepSeek R1 gebeten, eine entsprechende Animation auf dieser Basis zu erstellen, und das (nach 20 Sekunden fertige) Ergebnis hat mich wiederum positiv überrascht (der Slider war DeepSeek's "Idee" ;)).

---

Aufgabenstellung:

Please create a program based on the three.js framework where a changeable number (defined somewhere in the sourcecode, in the range of 1 to about 100) of blue spheres of the same size rotate around a common center.

---

Ergebnis:



Erzeugter HTML-Code:

<!DOCTYPE html> <html> <head> <title>Orbiting Spheres - Three.js</title> <style> body { margin: 0; overflow: hidden; } #container { position: relative; } #slider-container { position: absolute; top: 20px; left: 20px; z-index: 100; background: rgba(255, 255, 255, 0.8); padding: 10px; border-radius: 5px; } </style> </head> <body> <div id="container"> <div id="slider-container"> <label for="countSlider">Number of Spheres: </label> <input type="range" id="countSlider" min="1" max="100" value="10"> <span id="countDisplay">10</span> </div> </div> <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script> <script> let scene, camera, renderer, spheres = []; const radius = 2; const sphereSize = 0.2; let animationId; // Initial configuration const initialCount = 10; function init() { // Create scene scene = new THREE.Scene(); camera = new THREE.PerspectiveCamera(75, window.innerWidth/window.innerHeight, 0.1, 1000); renderer = new THREE.WebGLRenderer({ antialias: true }); renderer.setSize(window.innerWidth, window.innerHeight); document.getElementById('container').appendChild(renderer.domElement); // Position camera camera.position.z = 5; // Add ambient light const ambientLight = new THREE.AmbientLight(0xffffff, 0.5); scene.add(ambientLight); // Add directional light const directionalLight = new THREE.DirectionalLight(0xffffff, 0.8); directionalLight.position.set(1, 1, 3); scene.add(directionalLight); // Create initial spheres createSpheres(initialCount); // Setup slider const slider = document.getElementById('countSlider'); const countDisplay = document.getElementById('countDisplay'); slider.addEventListener('input', (e) => { const count = parseInt(e.target.value); countDisplay.textContent = count; createSpheres(count); }); // Handle window resize window.addEventListener('resize', onWindowResize, false); } function createSpheres(count) { // Remove existing spheres spheres.forEach(sphere => scene.remove(sphere)); spheres = []; // Create new spheres const geometry = new THREE.SphereGeometry(sphereSize, 32, 32); const material = new THREE.MeshPhongMaterial({ color: 0x0066ff, shininess: 100 }); for(let i = 0; i < count; i++) { const sphere = new THREE.Mesh(geometry, material); const angle = (i / count) * Math.PI * 2; sphere.position.x = Math.cos(angle) * radius; sphere.position.y = Math.sin(angle) * radius; spheres.push(sphere); scene.add(sphere); } } function animate() { const time = Date.now() * 0.001; spheres.forEach((sphere, i) => { const angle = (i / spheres.length) * Math.PI * 2 + time; sphere.position.x = Math.cos(angle) * radius; sphere.position.y = Math.sin(angle) * radius; }); renderer.render(scene, camera); animationId = requestAnimationFrame(animate); } function onWindowResize() { camera.aspect = window.innerWidth / window.innerHeight; camera.updateProjectionMatrix(); renderer.setSize(window.innerWidth, window.innerHeight); } // Start the application init(); animate(); </script> </body> </html>

Download (zum lokal im Webbrowser öffnen): Dateianhang: Rotating_Spheres_HTML.html (3 KB)

Viel besser geht kaum.

Deepseek ist auch eine Datenkrake. Es erstellt Nutzerprofile, die in natürlich in China gespeichert und ausgewertet werden.
Das geht bis hin zu Tastatureingabemustern oder -rhythmen.
Vor allem natürlich für die relevant, die sowieso schon im Big Brother Staat leben.

stefan33 schrieb:Das geht bis hin zu Tastatureingabemustern oder -rhythmen.

Und das um Personen zu identifizieren die mal von einem anderen Netzwerk aus zugreifen.
Mit welchen Daten aus dem Netz das dann noch kombiniert wird weiss niemand.
Das ist alles nicht wirklich nett was die da (alle) machen :D

@stefan33
Ich bin mir mittlerweile nicht mehr sicher, von welcher Organisation ich es eher dulde, ausspioniert zu werden.

Unsere Demokraten driften ja eh langsam aber sicher ab.

nocheinPoet schrieb:Gibt genug Videos inzwischen dazu im Netz, die DeepSeek R1 ohne Quantisierung so laufen lassen. Geht sogar auf einen "normalem" Windows PC, man braucht dazu drei SSD und legt auf jeder eben 200 GB Auslagerungsdatei an, in Summe also 600 GB und natürlich sollte man so viel RAM wie es geht auch so noch in der Kiste stecken haben.

Negev schrieb:Hab jetzt ebenfalls ein Guide gefunden. Am Ende heißt es, das die Performance "Absolutely Horrible" ist. Wenn das, dass ist, auf das du 2000 Euro drauf werfen willst, klar ...

Keine Ahnung was Du da gefunden hast an Guide, nennst leider keine Quelle, das mit den Auslagerungsdateien ist natürlich nicht so performant, und zerlegt vermutlich recht schnell die SSDs. Was aber ein System mit zwei EPYC und 512 GB RAM angeht, dass ist nicht "absolutely horrible", eventuell schaust Du da noch ein paar andere Guide zu an.

---

Negev schrieb:Wir reden hier über ein Leistung, die für den professionellen Bereich ausgeschlossen ist.

Nein, nicht wir, Du, und konkret auch nicht wirklich, da wären nämlichen T/s was zählt, hab nichts von Dir in diese Richtung gelesen. ;)

---

nocheinPoet schrieb:... ohne Quantisierung so laufen lassen ...

nocheinPoet schrieb:Wenn man das ganze Paket will, muss man das ganze Paket nehmen, man kann ja einen Freund besuchen, der in der Stadt wohnt und sehr gut ans Internet angebunden ist, der kann das dann schon mal runterladen, ...

Negev schrieb:Natürlich. Aber bei Hugging-Face bekommst du dieses Paket. So wie es der Entwickler eben zur Verfügung stellt. Das ist das Original. Wobei, diese Version quantisiert ist (Q8_0) da darfst du dir mal eben über 700 GB ziehen. Bei der Version ohne Quantisierung, also die fp16-Variante, kannst du dir 1300 GB gönnen. Das, was du mit 480G meinst, dürfte die Q4_K Variante sein. Da geht man schon einen Kompromiss ein. Besser, hab ich mir sagen lassen, ist ein Quantisierung von 5 oder 6.

Also, hier findet man was:

https://dev.to/askyt/deepseek-r1-671b-complete-hardware-requirements-optimal-deployment-setup-2e48
https://www.reddit.com/r/LocalLLaMA/comments/1ighj1n/what_hardware_needed_to_run_deepseek_r1_671b/
https://ollama.com/library/deepseek-r1:671b-fp16

Und ja, es gibt eine 671b Version fp16 die so 1,3 TB braucht. Mir ging es erstmal um 671b und ich hatte das nicht auf dem Zettel, dass die Version mit 480 GB wohl auch doch schon etwas quantisiert wurde.

Davon abgesehen, hab ich noch immer keinen Direktlink zum Runterladen einer 480 GB Version ...

---

Negev schrieb:Zu deinem Problem: du könntest deinen sehr guten Freund bitten, das er dir über Ollama das gewünschte Modell herunter lädt. Das kannst du dann Kopieren. Vermutlich gibt es auch einen Befehl für Hugging-Face, damit du nicht alle 163 Dateien anklicken musst, keine Ahnung. Lass mich aber gerne wissen, woher du diese "eine Datei" herunter geladen hast 😀.

Also ich habe schon bei Hugging-Face Modelle runtergeladen und das war eine Datei, glaube sogar ein Zip und das wurde dann in einen Ordner entpackt und in einen anderen geworfen und konnte ausgewählt werden.

---

nocheinPoet schrieb:Nun ja, die Frage ist, was man wie macht, will man es im VRAM einer Grafikkarte halten und da laufen lassen, oder über die CPU, so große Modelle auf Grafikkarten laufen zu lassen, ist sehr teuer, aber man kann es auch über die CPU machen und hier gibt es llama.cpp.

Negev schrieb:Ums nochmal klar zu machen. Generative KI alleine über die CPU zu betreiben, das muss man wirklich wollen. Mir machts keinen Spaß.

Schau Dir die Links an, da kommt man auf 8 T/s und so, das ist schon ausreichend. Du nennst auch keine Werte, was es nicht einfach macht hier mit Dir.

---

Negev schrieb:Tipp: nehme die 2000 Euro und kauf dir eine 5090, am besten noch einige Wochen warten, damit die Beta-Phase abgeschlossen ist.
https://www.heise.de/news/GeForce-RTX-5090-Einzelne-Berichte-ueber-schmelzende-Stecker-10276748.html

Ganz sicher nicht. Nie nicht, ich halte die Karte für großen Mist. Dann kann ich auch noch ein paar Monate länger warten, bis NVIDIA passende Hardware rausbringt. Es ist ja so, ein Server bringt ja auch ganz allgemein einen Mehrwert, man kann damit ja noch mehr machen, viele VMs laufen lassen und so lustige Dinge.

nocheinPoet schrieb:Keine Ahnung was Du da gefunden hast an Guide, nennst leider keine Quelle, [...] eventuell schaust Du da noch ein paar andere Guide zu an.

Du bist aber auch nicht gerade freizügig mit deinen Quellen.

nocheinPoet schrieb:Gibt genug Videos inzwischen dazu im Netz, die DeepSeek R1 ohne Quantisierung so laufen lassen.

Lass doch mal sehn.
Ich konnte bislang nur Videos finden, in denen die Ausgabe quälend langsam lief.

nocheinPoet schrieb:Schau Dir die Links an

nocheinPoet schrieb:https://dev.to/askyt/deepseek-r1-671b-complete-hardware-requirements-optimal-deployment-setup-2e48

Das ist so ziemlich das Gegenteil von dem, was du vor hast.

nocheinPoet schrieb:https://www.reddit.com/r/LocalLLaMA/comments/1ighj1n/what_hardware_needed_to_run_deepseek_r1_671b/

In deinem Link versteckt:
https://rasim.pro/blog/how-to-install-deepseek-r1-locally-full-6k-hardware-software-guide/

Beeindruckend. Bin interessiert (aber skeptisch bin ich noch). Aber er Arbeitet mit dem Q8 Modell. Gesamtkosten 6100 Dollar. Drei mal mehr als du anpeilst. Bitte Berichte aber!

nocheinPoet schrieb:Und ja, es gibt eine 671b Version fp16 die so 1,3 TB braucht. Mir ging es erstmal um 671b und ich hatte das nicht auf dem Zettel, dass die Version mit 480 GB wohl auch doch schon etwas quantisiert wurde.

Davon abgesehen, hab ich noch immer keinen Direktlink zum Runterladen einer 480 GB Version ...

Du scheinst informiert zu sein und findest keinen Download-Link? Irgendwie passt da etwas nicht zusammen...
Und klar, es gibt auch Modelle die man zu einer großen Datei zusammen führt. Das sind dann eher die kleineren. Aber warum dir das so wichtig ist, eine Große Datei zu haben, versteh ich nicht.

In diesem Guide oben, wirst du zu Huggin-Face geleitet.
https://huggingface.co/unsloth/DeepSeek-R1-GGUF/tree/main/DeepSeek-R1-Q4_K_M

Hätte ich 2000-6000 Euro übrig, würde ich dem Guide auch genau so folgen. Und sehen was passiert.

stefan33 schrieb:Deepseek ist auch eine Datenkrake. Es erstellt Nutzerprofile, die in natürlich in China gespeichert und ausgewertet werden.
Das geht bis hin zu Tastatureingabemustern oder -rhythmen.
Vor allem natürlich für die relevant, die sowieso schon im Big Brother Staat leben.

JoschiX schrieb:Und das um Personen zu identifizieren die mal von einem anderen Netzwerk aus zugreifen.
Mit welchen Daten aus dem Netz das dann noch kombiniert wird weiss niemand.
Das ist alles nicht wirklich nett was die da (alle) machen :D

Und deswegen meide ich chinesische IT-Waren wo es geht - grundsätzlich. Partiell als eine Art Boykott des Systems, weil diese Waren am Ende nun mal leider mehr als sonst wo aus Zwang mit etwaigen Erhebungen usw. mit dem System verbunden ist und nach dem Willen der Partei Daten erheben oder teilen müssen...

...und eben um eigene Risiken zu minimieren, so abstrakt sie sein mögen.

Ich finde es immer witzig, wenn manche sich über staatliche Eingriffsmaßnahmen (in unseren Breitengraden meine ich!) aufregen aber dann Unternehmen freiwillig alle möglichen Daten in den Rachen werfen und / oder diese Datensammlungen nicht wo sie können untersagen oder abschalten. Und wenn ich die Wahl habe werfe ich lieber westlichen Unternehmen die Daten, die ich eh teilen muss oder nur schlecht vermeiden kann, hin. Und keiner Autokratie.

Auch ist hier der Staat politisch-rechtlich wesentlich zurückhaltender und an Verfassungsrecht und im weiteren einfache Gesetzgebung gebunden. Das was China mit freier Hand macht? Hier nie im Leben. Selbst wenn man argumentiert oder glaubt, dass liberale Demokratien langsam erodieren und ggf. autoritärer werden: Du fährst dennoch im Schnitt und auf Zeit locker hier auf der sicheren Schiene.

Ich bleib dahingehend bei westlichen Produkten und mit westl. inkludiere ich auch Südkorea, Japan etc. Also Westen als Kollektiv liberaler Demokratien/repr. Monarchien, nicht nur was um uns und dann westwärts davon liegt.

Aber am Ende muss das jede Person selbst wissen wie sie was "konsumiert". Für viele kann es auch keinen Unterschied machen oder egal sein. Andererseits ergibt es wenig Sinn, wenn man vorher im Netz öfters bis rege China kritisiert hat um dann privat mit personenbezogenen Daten eine chinesische KI-Datenkraken-App zu bedienen und zu füttern, die ggf. die Profile dann irgendwann verbinden kann. Und weitere Infos über dich 'frei Haus' liefert.

Das wäre schwachsinnig/riskant sondergleichen, schon allein deswegen lasse ich die Finger davon :D

@Negev

Keine Ahnung was Du eigentlich von mir willst, irgendwie ist das nicht konstruktiv, wirkt auf mich destruktiv, so ein Subtext eben.

Ich hatte Quellen genannt, Du nicht wirklich welche zu Deinen Aussagen, und ja ich bin informiert und habe bisher keinen Link gefunden, wo ich eine fette Datei ziehen kann. Auch auf huggingface geht es im Kreis, da steht hier:

https://huggingface.co/deepseek-ai/DeepSeek-R1 auf der Seite unten zu

DeepSeek-R1 671B 37B 128K 🤗 HuggingFace (hier ein Download "Link") der aber auf die aktuelle Seite führt.

Spannend, dass Du noch immer nicht verstehst, warum ich eine große Datei haben will, hatte ich ja nur mehrfach schon geschrieben, ich bekomme hier 480 GB nicht mal eben in ein paar Tagen aus dem Netz geladen, also suche ich mir einen Freund, der zieht das runter und kopiert mir das auf eine SSD oder so. Da wäre es natürlich schön, wenn man ein Zip oder sonst wie eben nur eine Datei hätte.

Generell finde ich es besser, für ein Modell eine Datei zu haben, sie kann gerne noch Metadaten haben, dann wird sie eben in einen eigenen Ordner entpackt und der kommt in einen Ordner "models".

;)

@nocheinPoet
Ich hab mich doch schon teilweise Einsichtig gezeigt. Dieser Guide ist wirklich spannend.
https://rasim.pro/blog/how-to-install-deepseek-r1-locally-full-6k-hardware-software-guide/
Hätte ich Geld übrig, würde ich das gerne selber testen.

nocheinPoet schrieb:Nein, nicht wir, Du, und konkret auch nicht wirklich, da wären nämlichen T/s was zählt,

Und genau da ist auch ein Missverständnis!
6–8 tokens per second ist für einen Nutzer wirklich fein. Aber:

nocheinPoet schrieb:Es ist ja so, ein Server bringt ja auch ganz allgemein einen Mehrwert, man kann damit ja noch mehr machen, viele VMs laufen lassen und so lustige Dinge.

Das ganz ist ein HomeLab Projekt! Während du deine Kiste mit deiner Anfrage beschäftigst. Welche andere Dienste willst du da noch ausführen?

nocheinPoet schrieb:Spannend, dass Du noch immer nicht verstehst, warum ich eine große Datei haben will, hatte ich ja nur mehrfach schon geschrieben, ich bekomme hier 480 GB nicht mal eben in ein paar Tagen aus dem Netz geladen, also suche ich mir einen Freund, der zieht das runter und kopiert mir das auf eine SSD oder so. Da wäre es natürlich schön, wenn man ein Zip oder sonst wie eben nur eine Datei hätte.

Ich fürchte, das mir das auch für immer verborgen bleiben wird. Du führst deinen Freund als Grund an. Warum kann er (oder du) nicht einfach diese 9 Dateien herunter laden? Warum läuft das nicht auf das selbe hinaus?
Bei 163 Dateien hätte würde ich selbst die Frage stellen, wie man das automatisieren kann (über Hugging-Face-CLI oder über Ollama) aber bei 9 Dateien würde ich kein Drama machen.

---

Wie gesagt, bitte berichte von deinem Projekt!

Negev schrieb:Das ganz ist ein HomeLab Projekt! Während du deine Kiste mit deiner Anfrage beschäftigst. Welche andere Dienste willst du da noch ausführen?

Da gibt es viel, Docker, einen Plex-Server, man kann auch drauf entwickeln und als Tabreiter-Messi könnte ich endlich mal die 10.000 Tabs in 50 Fenster knacken. :D

Also mal ganz im Ernst, es ist dann ja auch ECC-RAM, das ist schon was, ...

---

Negev schrieb:Ich fürchte, das mir das auch für immer verborgen bleiben wird. Du führst deinen Freund als Grund an. Warum kann er (oder du) nicht einfach diese 9 Dateien herunter laden? Warum läuft das nicht auf das selbe hinaus?
Bei 163 Dateien hätte würde ich selbst die Frage stellen, wie man das automatisieren kann (über Hugging-Face-CLI oder über Ollama) aber bei 9 Dateien würde ich kein Drama machen.

So einfach wie nur möglich sollte es sein.

Aber ich habe davon mal abgesehen heute Nacht eine andere Idee gehabt, es ist ja bekannt, dass es auch auf einen "normalen" PC läuft, wenn man eine große Auslagerungsdatei hat.

Schauen wir mal hier:


Bildquelle: https://www.amazon.de/EZDIY-FAB-Erweiterungskarte-Unterst%C3%BCtzt-Intel-Plattform-AMD-Plattform-DE2-M2-RAID-4/dp/B0B5G6MN79

Dazu vier Crucial P310 SSD 1TB M.2 2280 PCIe Gen4 NVMe Interne SSD, bis 7.100 MB/s



Und das als Raid angebunden, sollte schon echt schnell sein. Kein Vergleich zu echtem RAM, aber immerhin.

Wenn man Board schon dafür hat, sind das 325 € die man ausgibt, und sollte das große Model laufen lassen können. Klar halten die SSD vermutlich max. ein Jahr den Trafik aus, muss man eben sehen, und man wird wohl mehr bei so 1 T/s liegen, aber damit könnte man bei dem Preis für den Anfang doch schon mal klar kommen.

Ich muss mir das weiter überlegen, das mit dem SERVER ist schon gewagt, man baut so was nicht wie einen einfachen PC, man braucht ein Drehmomentschraubendreher um die EPYC mit dem richtigen Drehmoment anzuziehen, und wenn man die Dinge gebraucht kauft, ist nichts mit Garantie. Hier also mal eben 3.500 € zu investieren um dann im Regen zu stehen, ... muss man sich in Ruhe überlegen.

Klar ist aber, die kleineren Modelle unter 20 GB taugen nicht wirklich viel. Wenn man mit so einer KI richtig arbeiten will, also auch Code erzeugen, denn man in seinen Projekten dann nutzt, muss man schon richtig was haben.

Nachdem ich DeepSeek R1 seit Verfügbarkeit sehr intensiv nutze, ist es mir gerade zum ersten Mal passiert, dass das Modell an einer Aufgabe grundsätzlich gescheitert ist. Es geht um die Simulation des in diesem Beitrag analysierten mechanischen Problems. Die besondere Schwierigkeit bei diesem Problem liegt darin, dass drei Objekte gleichzeitig kollidieren, was sich nicht -- wie ich in dem verlinkten Beitrag erläutere -- sequentiell berechnen lässt. Ich hatte DeepSeek R1 dazu die folgende Aufgabe gestellt (tatsächlich in leicht anderer Form, was aber ziemlich sicher keine Rolle spielt):

Aufgabenstellung:

Please create an animation based on the three.js framework according to the following description:

• Two solid yellow spheres move horizontally, with no horizontal and a certain vertical distance, and with the same speed into the scene from the right.

• A solid blue right-angled triangular prism moves with same speed than the spheres into the scene from the left. The longitudinal axis of the prism is oriented perpendicular to the plane of the scene, and the hypothenuse is oriented vertically. The right-angled edge of the prism points into the direction of movement. The length of the hypothenuse of the triangle equals about six times the diameter of the spheres.

• The vertical positions of the spheres are such that they will hit the prism in the respective middle of the lower and the upper plane of the prism oriented toward the spheres.

• The mass of either sphere equals one half of the mass of the prism. The spheres and the prism as perfectly elastic.

• Model the collision as physically accurate as possible.

Zum einen stimmte mit der Animation einiges nicht, und zum anderen war die Kollisionsberechnung stark vereinfacht, und sehr weit von einer "physically accuraten" Berechnung entfernt. Dazu meinte DeepSeek R1: "For more complex collisions, a full 3D physics engine would be needed". So war das natürlich nicht gedacht. ;)

Da ich aus bestimmten Gründen meinen regulären OpenAI-Account nicht für meine Aktivitäten hier verwenden möchte, wäre es nett, wenn jemand anders mit Zugang zum o3-mini-high-Modell mal testen würde, was dieses Modell aus der Aufgabenstellung macht.

Ich habe die Aufgabenstellung insbesondere deshalb hier eingestellt, damit sich testen lässt, wie zukünftige KI-Modelle damit zurechtkommen. Die Fortschrittskurve verläuft derzeit sehr steil, so dass ich vermuten würde, dass in den nächsten Monaten ein Modell -- von wem auch immer -- herauskommen wird, das in der Lage ist, die Aufgabe korrekt zu lösen.

@nocheinPoet
Genau dein Thema, würd ich behaupten:

So läuft DeepSeek lokal mit voller Qualität

Externer Inhalt
Durch das Abspielen werden Daten an Youtube übermittelt und ggf. Cookies gesetzt.

Ich bin teilweise beeindruckt.
Interessant finde ich, das die Performance wohl keinen Einfluss auf das Ergebnis hat.
Die c't Redaktion hat mit ihrem Server 3 T/s gemessen. Andere Guides kommen auf 6 T/s. Und das immer für einen Nutzer? Auch eine Spannende Frage ist die nach den Kosten und hier kann die CPU bei weitem nicht mithalten!

Dieses Projekt ist nur etwas für Enthusiasten.

nocheinPoet schrieb:das mit den Auslagerungsdateien ist natürlich nicht so performant, und zerlegt vermutlich recht schnell die SSDs.

Das treibt mir auch noch Fragezeichen auf die Stirn. Du willst deinen RAM mit SSD Speicher erweitern, schreibst aber, das du 6 - 8 T/s erwartest?

Könntest du bitte einen Artikel teilen?
Deine Links beschreiben einfach nur, welche Hardware man ink. GPU benötigt bzw. wenn man nur CPU und RAM nutzen will.

---

Fazit: Spannend. Aber ich warte!
Ich gebe nur anonymisierte Daten bei OpenAI oder Deepseek ein. Falls ich mehr Anonymität will, gibt es sicher Server in der EU, die DeepSeek Modelle anbieten. Damit komm ich definitiv auch günstiger weg - um ein Faktor X.

Die Zwangspausen bei deepseek sind beim Ausprobieren von Simulationen ziemlich nervtötend. Ich habe jetzt einmal die Free-Version von ChatGPT o3-mini mit eingeschaltetem Reason-Button etwas intensiver getestet. Wenn man öfter etwas ausprobieren will, kommt man damit wesentlich flotter voran. Im Prinzip kann man nach jeder Zeile einmal nachschauen, ob alles so läuft, wie man sich das vorgestellt hat. ChatGPT soll bei dem Versuch den Quellcode für eine einfache Simulation von einem Wisch-Bot generieren. Zum Programmieren habe ich Processing vorgegeben. Eine ziemlich einfache Variante von Java.

Die Forderung an ChatGPT:

Ich möchte ein Programm in Processing 4 erstellen.
Benötigt wird eine Grundfläche von 1200 Pix * 800 Pix. in der Farbe Hellbraun.
Auf der Fläche werden 3 runde als Hindernisse bezeichnete Kreise platziert. Die Kreise haben einen Durchmesser von 100 Pix, erhalten die Farbe Dunkelbraun und werden in weiß mit "Hindernis" beschriftet.
Die Hindernisse sollen sich innerhalb der Grundfläche mit der Maus verschieben lassen.
Zusätzlich wird noch ein als Wischer bezeichneter dunkelgrüner Kreis mit dem dem Durchmesser von 80 Pix und der hellgrünen Beschriftung "Wischer" auf der Fläche platziert. Der soll sich ebenfalls mit der Maus bewegen lassen.
Wenn der Wischer bewegt wird, ändert sich die Farbe der Grundfläche unter dem Wischer in ein Hellgrün.
Die Ränder des Wischers dürfen die Ränder Der Hindernisse nicht übeschreiten. Die Ränder der der Grundfläche dürfen vom Wischer auch nicht überschritten werden.
Der Wischer soll sich jetzt innerhalb der Grundfläche so bewegen, dass er auf einem möglichst kurzem Weg die Grundfläche außerhalb der Hindernisse in ein Hellgün umfärbt.
Nach Abschluss des Vorgangs, soll der Wischer gegebenenfalls noch die Flächen nacharbeiten, die nach Verschieben eines Hindernisses zugänglich werden.

ChatGPT-Code:

Spoiler// Grundeinstellungen
final int WIDTH_CANVAS = 1200;
final int HEIGHT_CANVAS = 800;

// Raster für die „Reinigungszustände“
final int cellSize = 10;
final int cols = WIDTH_CANVAS / cellSize; // 120
final int rows = HEIGHT_CANVAS / cellSize; // 80
boolean[][] cleaned = new boolean[cols][rows];

// Farben (RGB)
color baseColor = color(222, 184, 135); // Hellbraun (z. B. Burlywood)
color cleanedColor = color(144, 238, 144); // Hellgrün
color obstacleColor = color(101, 67, 33); // Dunkelbraun
color wiperColor = color(0, 100, 0); // Dunkelgrün
color wiperTextColor = color(144, 238, 144); // Hellgrün
color obstacleTextColor = color(255);

// Globale Variablen
ArrayList<Obstacle> obstacles;
Wiper wiper;
float wiperSpeed = 4; // Geschwindigkeit in Pixel pro Frame

PFont font;

// Für Maus-Interaktion (Drag & Drop)
boolean draggingWiper = false;
Obstacle draggingObstacle = null;

// Die settings()-Methode ist der richtige Ort für den size()-Aufruf.
void settings() {
size(WIDTH_CANVAS, HEIGHT_CANVAS);
}

void setup() {
// Schriftart für Beschriftungen
font = createFont("Arial", 16);
textFont(font);

// Alle Zellen als "ungeputzt" initialisieren
for (int i = 0; i < cols; i++) {
for (int j = 0; j < rows; j++) {
cleaned[j] = false;
}
}

// Erzeuge drei Hindernisse – ihre Zentren müssen innerhalb
// des Bereichs [r, width–r] bzw. [r, height–r] liegen.
obstacles = new ArrayList<Obstacle>();
obstacles.add(new Obstacle(300, 200));
obstacles.add(new Obstacle(600, 400));
obstacles.add(new Obstacle(900, 600));

// Erzeuge den Wischer in der Mitte der Grundfläche.
wiper = new Wiper(WIDTH_CANVAS/2, HEIGHT_CANVAS/2);
}

void draw() {
// Automatisches Reinigen, falls der Wischer nicht per Maus bewegt wird.
if (!draggingWiper) {
if (wiper.path == null || wiper.path.isEmpty() || !wiper.isPathValid()) {
PVector target = findNearestDirtyAccessibleCell();
if (target != null) {
ArrayList<PVector> newPath = computePath(wiper.position, target);
if (newPath != null && newPath.size() > 0) {
wiper.setPath(newPath);
}
}
}
wiper.update();
markCleaned(wiper.position);
}

// Zeichne den Boden
drawFloor();

// Zeichne die Hindernisse
for (Obstacle o : obstacles) {
o.display();
}

// Zeichne den Wischer
wiper.display();

// Optional: Zeichne den geplanten Pfad (auskommentiert)
// wiper.drawPath();
}


/// ─── FUNKTIONEN FÜR DEN "REINIGUNGSSTATUS" ─────────────────────────────

void markCleaned(PVector pos) {
for (int i = 0; i < cols; i++) {
for (int j = 0; j < rows; j++) {
if (!cleaned[j]) {
float cx = i * cellSize + cellSize/2;
float cy = j * cellSize + cellSize/2;
if (dist(pos.x, pos.y, cx, cy) < wiper.r) {
cleaned[j] = true;
}
}
}
}
}

void drawFloor() {
noStroke();
for (int i = 0; i < cols; i++) {
for (int j = 0; j < rows; j++) {
fill(cleaned[j] ? cleanedColor : baseColor);
rect(i * cellSize, j * cellSize, cellSize, cellSize);
}
}
}

PVector findNearestDirtyAccessibleCell() {
PVector best = null;
float bestDist = Float.MAX_VALUE;
for (int i = 0; i < cols; i++) {
for (int j = 0; j < rows; j++) {
if (!cleaned[j]) {
float cx = i * cellSize + cellSize/2;
float cy = j * cellSize + cellSize/2;
PVector cellCenter = new PVector(cx, cy);
if (isAccessible(cellCenter)) {
float d = PVector.dist(wiper.position, cellCenter);
if (d < bestDist) {
bestDist = d;
best = cellCenter;
}
}
}
}
}
return best;
}

boolean isAccessible(PVector pos) {
if (pos.x < wiper.r || pos.x > WIDTH_CANVAS - wiper.r) return false;
if (pos.y < wiper.r || pos.y > HEIGHT_CANVAS - wiper.r) return false;
for (Obstacle o : obstacles) {
if (PVector.dist(pos, o.position) < (wiper.r + o.r)) {
return false;
}
}
return true;
}


/// ─── PFADPLANUNG MIT A* ─────────────────────────────────────────────

ArrayList<PVector> computePath(PVector startPos, PVector targetPos) {
int startI = int(startPos.x / cellSize);
int startJ = int(startPos.y / cellSize);
int targetI = int(targetPos.x / cellSize);
int targetJ = int(targetPos.y / cellSize);

Node[][] nodes = new Node[cols][rows];
for (int i = 0; i < cols; i++) {
for (int j = 0; j < rows; j++) {
nodes[i][j] = new Node(i, j);
float cx = i * cellSize + cellSize/2;
float cy = j * cellSize + cellSize/2;
if (!isAccessible(new PVector(cx, cy))) {
nodes[i][j].walkable = false;
}
}
}

ArrayList<Node> openList = new ArrayList<Node>();
ArrayList<Node> closedList = new ArrayList<Node>();

Node startNode = nodes[startI][startJ];
Node targetNode = nodes[targetI][targetJ];
startNode.g = 0;
startNode.h = dist(startI, startJ, targetI, targetJ);
startNode.f = startNode.h;
openList.add(startNode);

while (!openList.isEmpty()) {
Node current = openList.get(0);
for (Node n : openList) {
if (n.f < current.f) {
current = n;
}
}
if (current == targetNode) {
ArrayList<PVector> path = new ArrayList<PVector>();
Node temp = current;
while (temp != null) {
float cx = temp.i * cellSize + cellSize/2;
float cy = temp.j * cellSize + cellSize/2;
path.add(0, new PVector(cx, cy));
temp = temp.parent;
}
return path;
}
openList.remove(current);
closedList.add(current);

for (int di = -1; di <= 1; di++) {
for (int dj = -1; dj <= 1; dj++) {
if (di == 0 && dj == 0) continue;
int ni = current.i + di;
int nj = current.j + dj;
if (ni < 0 || ni >= cols || nj < 0 || nj >= rows) continue;
Node neighbor = nodes[ni][nj];
if (!neighbor.walkable || closedList.contains(neighbor)) continue;
float cost = (di != 0 && dj != 0) ? 1.414 : 1;
float newG = current.g + cost;
if (!openList.contains(neighbor) || newG < neighbor.g) {
neighbor.g = newG;
neighbor.h = dist(ni, nj, targetI, targetJ);
neighbor.f = neighbor.g + neighbor.h;
neighbor.parent = current;
if (!openList.contains(neighbor)) {
openList.add(neighbor);
}
}
}
}
}
return null; // Kein Pfad gefunden
}

class Node {
int i, j;
boolean walkable = true;
float g = Float.MAX_VALUE;
float h = 0;
float f = Float.MAX_VALUE;
Node parent = null;

Node(int i, int j) {
this.i = i;
this.j = j;
}
}


/// ─── KLASSEN FÜR OBJEKTE ─────────────────────────────────────────────

class Obstacle {
PVector position;
float r = 50;

Obstacle(float x, float y) {
position = new PVector(x, y);
}

void display() {
fill(obstacleColor);
noStroke();
ellipse(position.x, position.y, r*2, r*2);
fill(obstacleTextColor);
textAlign(CENTER, CENTER);
text("Hindernis", position.x, position.y);
}

boolean isMouseOver() {
return dist(mouseX, mouseY, position.x, position.y) <= r;
}

void setPosition(float x, float y) {
position.x = constrain(x, r, WIDTH_CANVAS - r);
position.y = constrain(y, r, HEIGHT_CANVAS - r);
}
}

class Wiper {
PVector position;
float r = 40;
ArrayList<PVector> path;

Wiper(float x, float y) {
position = new PVector(x, y);
path = new ArrayList<PVector>();
}

void update() {
if (path != null && !path.isEmpty()) {
PVector target = path.get(0);
PVector dir = PVector.sub(target, position);
if (dir.mag() < wiperSpeed) {
position = target.copy();
path.remove(0);
} else {
dir.normalize();
dir.mult(wiperSpeed);
position.add(dir);
}
position.x = constrain(position.x, r, WIDTH_CANVAS - r);
position.y = constrain(position.y, r, HEIGHT_CANVAS - r);
}
}

void display() {
fill(wiperColor);
noStroke();
ellipse(position.x, position.y, r*2, r*2);
fill(wiperTextColor);
textAlign(CENTER, CENTER);
text("Wischer", position.x, position.y);
}

void setPath(ArrayList<PVector> newPath) {
path = newPath;
}

boolean isPathValid() {
if (path == null) return false;
for (PVector p : path) {
if (!isAccessible(p)) return false;
}
return true;
}

// Optional: Visualisierung des Pfades
void drawPath() {
if (path != null && path.size() > 0) {
stroke(0, 0, 255);
noFill();
beginShape();
vertex(position.x, position.y);
for (PVector p : path) {
vertex(p.x, p.y);
}
endShape();
}
}

boolean isMouseOver() {
return dist(mouseX, mouseY, position.x, position.y) <= r;
}

void setPosition(float x, float y) {
PVector newPos = new PVector(x, y);
newPos.x = constrain(newPos.x, r, WIDTH_CANVAS - r);
newPos.y = constrain(newPos.y, r, HEIGHT_CANVAS - r);
for (Obstacle o : obstacles) {
float minDist = r + o.r;
float d = PVector.dist(newPos, o.position);
if (d < minDist) {
PVector away = PVector.sub(newPos, o.position);
away.normalize();
away.mult(minDist);
newPos = PVector.add(o.position, away);
newPos.x = constrain(newPos.x, r, WIDTH_CANVAS - r);
newPos.y = constrain(newPos.y, r, HEIGHT_CANVAS - r);
}
}
position = newPos;
}
}


/// ─── MAUSINTERAKTION ─────────────────────────────────────────────

void mousePressed() {
for (Obstacle o : obstacles) {
if (o.isMouseOver()) {
draggingObstacle = o;
return;
}
}
if (wiper.isMouseOver()) {
draggingWiper = true;
return;
}
}

void mouseDragged() {
if (draggingObstacle != null) {
draggingObstacle.setPosition(mouseX, mouseY);
wiper.path.clear();
}
if (draggingWiper) {
wiper.setPosition(mouseX, mouseY);
markCleaned(wiper.position);
wiper.path.clear();
}
}

void mouseReleased() {
draggingObstacle = null;
draggingWiper = false;
}




Das Ergebnis ist wirklich verblüffend. Der Wischer arbeitet zügig und bewegt sich auch um die Hindernisse herum. Wenn man ihn während der Bearbeitung mit der Maus umpositioniert, arbeitet er auch fehlerlos weiter. Er macht sich auch umgehend auf den Weg zum Nachwischen, wenn nach getaner Arbeit ein Hindernis verschoben wird. Die nicht gewischten Stellen könnte man ihm bestimmt auch noch abgewöhnen. In einigen Fällen hat ChatGPT die size() Anweisung im Programm falsch platziert. Der Bot korrigiert den Quellcode aber problemlos, wenn man ihm die Fehlermeldung mitteilt:

»Fehlermeldung: IllegalStateException: size() cannot be used here, see https://processing.org/reference/size_.html

Die Fehlermeldung besagt, dass der Aufruf von size() nicht im globalen Bereich erfolgen darf. In Processing 3 und 4 muss der Aufruf in der settings()-Methode stehen.

Mit exakt der gleichen Forderung habe ich zum Schluss noch versucht, ein entsprechendes Programm mit deepseek zu erzeugen. Das Programm hat zunächst nicht funktioniert. Der Wischer hat sich nicht bewegt. Im Zuge einer längeren Unterhaltung hat deepdeek dann noch ein paar Versuche gemacht, das Programm zum Laufen zu bringen. Das ist irgendwann auch gelungen. Das Ergebnis ist allerdings nicht so besonders. Der Wischer läuft kreuz und quer über die Grundfläche und wird vermutlich nie fertig werden. Beim Versuch, das Problem zu beseitigen, hat deepseek nur noch Programme generiert, die nicht gelaufen sind.

Deepseek-Code:

Spoiler
PGraphics bufferBase, bufferPaint;
ArrayList<Obstacle> obstacles = new ArrayList<Obstacle>();
Wischer wischer;
color grundFarbe = color(181, 101, 29);
color wischerFarbe = color(0, 100, 0);
boolean fertig = false;

void setup() {
size(1200, 800);
bufferBase = createGraphics(width, height);
bufferPaint = createGraphics(width, height);

initBuffers();

// Hindernisse
obstacles.add(new Obstacle(300, 300));
obstacles.add(new Obstacle(600, 400));
obstacles.add(new Obstacle(900, 500));

// Wischer
wischer = new Wischer(100, 100);
frameRate(60);
}

void draw() {
// Zeichne beide Buffer
image(bufferBase, 0, 0);
image(bufferPaint, 0, 0);

// Automatische Bewegung
if (!fertig) {
wischer.autoMove();
}

drawObstacles();
wischer.display();

// Überprüfe Fertigstellung
fertig = wischer.checkCompletion();
}

void initBuffers() {
bufferBase.beginDraw();
bufferBase.background(grundFarbe);
bufferBase.endDraw();

bufferPaint.beginDraw();
bufferPaint.clear();
bufferPaint.endDraw();
}

void mousePressed() {
for (Obstacle o : obstacles) {
if (o.isOver(mouseX, mouseY)) {
o.dragging = true;
break;
}
}
}

void mouseDragged() {
for (Obstacle o : obstacles) {
if (o.dragging) {
o.move(mouseX, mouseY);
break;
}
}
}

void mouseReleased() {
for (Obstacle o : obstacles) o.dragging = false;
fertig = false; // Ermögliche Nachbearbeitung
}

class Obstacle {
PVector pos;
boolean dragging = false;
float d = 100;

Obstacle(float x, float y) {
pos = new PVector(x, y);
}

boolean isOver(float x, float y) {
return dist(x, y, pos.x, pos.y) < d/2;
}

void move(float x, float y) {
pos.set(constrain(x, d/2, width-d/2), constrain(y, d/2, height-d/2));
updateBaseBuffer();
}

void display() {
fill(#4D2E1E);
noStroke();
ellipse(pos.x, pos.y, d, d);
fill(255);
textAlign(CENTER, CENTER);
text("Hindernis", pos.x, pos.y);
}
}

class Wischer {
PVector pos;
float d = 80;
PVector target;

Wischer(float x, float y) {
pos = new PVector(x, y);
target = new PVector(x, y);
}

void autoMove() {
// Erstelle neuen Zielpunkt bei Erreichen des Ziels
if (PVector.dist(pos, target) < 5) {
target = findNewTarget();
}

// Bewegungsberechnung
PVector movement = PVector.sub(target, pos).limit(2);
PVector newPos = PVector.add(pos, movement);

// Kollisionsprüfung
if (!checkCollision(newPos)) {
pos = newPos;
paintArea();
} else {
target = findNewTarget(); // Neues Ziel bei Kollision
}
}

PVector findNewTarget() {
PVector newTarget = new PVector();
int versuche = 0;
do {
newTarget.x = random(d/2, width-d/2);
newTarget.y = random(d/2, height-d/2);
versuche++;
} while (checkCollision(newTarget) && versuche < 100);

return versuche < 100 ? newTarget : pos;
}

boolean checkCollision(PVector p) {
// Fensterränder
if (p.x < d/2 || p.x > width-d/2 || p.y < d/2 || p.y > height-d/2) return true;

// Hindernisse
for (Obstacle o : obstacles) {
if (PVector.dist(p, o.pos) < (d/2 + o.d/2)) return true;
}
return false;
}

void paintArea() {
bufferPaint.beginDraw();
bufferPaint.fill(#90EE90, 50);
bufferPaint.noStroke();
bufferPaint.ellipse(pos.x, pos.y, d, d);
bufferPaint.endDraw();
}

boolean checkCompletion() {
bufferPaint.loadPixels();
int painted = 0;
for (int i = 0; i < bufferPaint.pixels.length; i++) {
if (bufferPaint.pixels[i] == #90EE90) painted++;
}
float coverage = (float)painted / (width*height);
return coverage > 0.95;
}

void display() {
fill(wischerFarbe);
noStroke();
ellipse(pos.x, pos.y, d, d);
fill(#90EE90);
textAlign(CENTER, CENTER);
text("Wischer", pos.x, pos.y);
}
}

void updateBaseBuffer() {
bufferBase.beginDraw();
bufferBase.background(grundFarbe);
for (Obstacle o : obstacles) {
bufferBase.fill(#4D2E1E);
bufferBase.noStroke();
bufferBase.ellipse(o.pos.x, o.pos.y, o.d, o.d);
}
bufferBase.endDraw();
}

void drawObstacles() {
for (Obstacle o : obstacles) {
o.display();
}
}



Das hat mich jetzt aber schon erstaunt. Im ersten Versuch habe ich mit beiden Systemen etliche XY-Diagramme mit mehreren Y-Achsen erzeugen lassen. Da haben beide Systeme immer gute Ergebnisse gebracht. Die von deepseek waren dabei eher etwas besser.[/i][/i][/i]

Ich habe DeepSeek heute mal ne nautische Frage gestellt:

wenn eine Yacht 2,2 Meter Tiefgang hat, wann ist dann der beste Zeitpunkt heute den Yachthafen von La Rochelle zu verlassen?

Zur Erläuterung: La Rochelle habe ich gewählt, weil die Einfahrt nur eine Kartentiefe von 0,9m hat. Man kann dort mit einer normalen Yacht nicht rein oder raus ohne die Gezeiten zu beachten.

Denkvorgang:
Spoiler

Okay, der Nutzer möchte wissen, wann eine Yacht mit 2,2 Meter Tiefgang heute den Yachthafen von La Rochelle verlassen sollte. Zuerst muss ich die Gezeiteninformationen für den 15. Februar 2025 in La Rochelle finden.

In den Suchergebnissen gibt es mehrere Webseiten mit Gezeitenzeiten. Webseite 5 (Tide-Forecast) nennt die heutigen Gezeiten: Niedrigwasser um 00:15 Uhr (1,25 m) und 12:36 Uhr (1,27 m), Hochwasser um 06:02 Uhr (5,9 m) und 18:12 Uhr (5,65 m). Das passt zu Webseite 2 und 6, die ähnliche Zeiten angeben.

Da der Tiefgang der Yacht 2,2 m beträgt, muss der Wasserstand ausreichend hoch sein. Sicherheitshalber sollte man eine Pufferzone einplanen, vielleicht 0,5 m, also mindestens 2,7 m Wassertiefe.

Hochwasserzeiten sind um 06:02 und 18:12 Uhr mit 5,9 m bzw. 5,65 m. Niedrigwasser ist um 12:36 Uhr bei 1,27 m. Da Niedrigwasser zu niedrig ist, muss die Yacht während der Hochwasserzeiten auslaufen.

Allerdings ist es wichtig, nicht nur die Hochwasserzeit, sondern auch die Gezeitenströmung zu beachten. Idealerweise verlässt man den Hafen bei auflaufendem Wasser (Flut), um von der Strömung zu profitieren. Die Flutzeiten heute sind 06:02-12:36 Uhr (Ebbe) und dann wieder 12:36-18:12 Uhr (Flut).

Der beste Zeitpunkt wäre also während der ansteigenden Flut vor dem Hochwasser. Zwischen 12:36 Uhr (Ende der Ebbe) und 18:12 Uhr (nächstes Hochwasser) steigt das Wasser wieder an. Allerdings ist das Hochwasser am Nachmittag um 18:12 Uhr, daher könnte die beste Zeit einige Stunden davor liegen, wenn die Wassertiefe bereits ausreicht, aber die Strömung noch günstig ist.

Zusammenfassend sind die Zeitfenster um die Hochwasserzeiten herum am besten, wobei der Vormittag wegen des höheren Hochwassers (5,9 m) möglicherweise mehr Spielraum bietet. Allerdings muss die Yacht den Hafen verlassen, wenn die Wassertiefe ausreichend ist, also etwa 2-3 Stunden vor und nach dem Hochwasser.

Man sollte auch die genauen Zeiten und Höhen der Gezeiten überprüfen und mögliche Sicherheitspuffer einrechnen. Webseite 4 und 9 erwähnen zudem Gezeitenkoeffizienten, die heute bei 89 liegen, was auf eine starke Gezeitenströmung hindeutet. Das könnte die Planung beeinflussen, da stärkere Strömungen die Navigation erschweren können.

Insgesamt sind die besten Zeiten heute früh morgens um 06:02 Uhr oder abends um 18:12 Uhr, wobei die genauen Zeiträume um diese Hochwasserzeiten herum liegen. Es ist wichtig, lokale Gegebenheiten und aktuelle Wetterbedingungen zu berücksichtigen, wie auf Webseite 3 und 7 erwähnt, wo Wind und Wetter erwähnt werden.

Ergebnis:

Für eine Yacht mit 2,2 Meter Tiefgang ist der beste Zeitpunkt zum Verlassen des Yachthafens von La Rochelle heute (15. Februar 2025) während der Hochwasserphasen, um ausreichend Wassertiefe zu gewährleisten. Hier die detaillierte Analyse basierend auf den Gezeiteninformationen:

Heutige Gezeitenzeiten in La Rochelle 4714:

Hochwasser (Flut):
06:02 Uhr – Höhe: 5,90 m
18:12 Uhr – Höhe: 5,65 m
Niedrigwasser (Ebbe):
00:15 Uhr – Höhe: 1,25 m
12:36 Uhr – Höhe: 1,27 m
Empfohlene Zeitfenster:

Um das erste Hochwasser (06:02 Uhr):
Die Wassertiefe erreicht 5,90 m, was mehr als ausreicht für den Tiefgang von 2,2 m.
Idealer Zeitraum: 1–2 Stunden vor und nach dem Hochwasser (ca. 05:00–08:00 Uhr), um von der auflaufenden Flut zu profitieren und starke Strömungen zu vermeiden 714.
Um das zweite Hochwasser (18:12 Uhr):
Die Wassertiefe beträgt 5,65 m, ebenfalls sicher für die Yacht.
Zeitfenster: 16:30–19:30 Uhr. Beachten Sie, dass die Sicht bei Dunkelheit eingeschränkt sein könnte (Sonnenuntergang um 18:30 Uhr) 514.
Wichtige Hinweise:

Mindestwassertiefe:
Für 2,2 m Tiefgang sollte die Wassertiefe mindestens 2,7–3,0 m betragen (inkl. Sicherheitspuffer). Dies ist nur während der Hochwasserphasen gegeben 915.
Gezeitenströmung:
Die Strömung ist während der Flut am stärksten. Vermeiden Sie die Zeit des stärksten Stroms (ca. 1 Stunde vor und nach dem Hochwasser), um die Manövrierfähigkeit zu gewährleisten 9.
Wetterbedingungen:
Heute herrscht klarer Himmel mit einer Windgeschwindigkeit von 10 mph – gute Bedingungen für die Ausfahrt 5.
Zusammenfassung:

Optimaler Zeitraum:
05:00–08:00 Uhr (morgens) oder 16:30–19:30 Uhr (abends).
Vermeiden Sie die Ebbezeiten (insbesondere 12:36 Uhr), da die Wassertiefe dann unter 1,3 m sinkt und ein Grundrisiko besteht 714.
Für präzise Navigation konsultieren Sie bitte zusätzlich lokale Lotsenhinweise oder Echtzeitdaten, da Gezeitenvorhersagen leichte Abweichungen aufweisen können 915.

Eigentlich ne ordentliche Arbeit. Es fehlt nur die Berücksichtigung, dass die Einfahrt ja schon eine Kartentiefe von 0,9 m hat und die auf die Gezeiten noch drauf gerechnet werden müssen. Die tatsächliche Wassertiefe ist also um eben jene 0,9m größer als DeepSeek angenommen hat. Womit das Zeitfenster zu ein und auslaufen noch größer wird.

Also Seekarten scheinen nicht zum Trainingsmaterial gehört zu haben. Trotzdem beeindruckend welche Kriterien er so berücksichtigt.

alhambra schrieb:Es fehlt nur die Berücksichtigung, dass die Einfahrt ja schon eine Kartentiefe von 0,9 m hat und die auf die Gezeiten noch drauf gerechnet werden müssen.

Auf Englisch gefragt, fällt die Antwort bzw. der "Gedankengang" deutlich umfangreicher aus, und dies wird zumindest theoretisch erwähnt.

Therefore, the user needs to know the charted depth of the marina's channels and entrance. Without that information, it's hard to be precise. However, assuming that the marina has a certain depth, the key is to ensure that the sum of the charted depth and the current tide height exceeds the yacht's draft plus safety margin.

Alternatively, perhaps the critical point has a charted depth of 1.5 meters. Then, at low tide (1.5m tide), depth is 1.5 + 1.5 = 3.0m, which is safe. Then the yacht can leave anytime. But maybe the charted depth is lower. This is why knowing the exact charted depth is crucial.

Poipoi schrieb:Auf Englisch gefragt, fällt die Antwort bzw. der "Gedankengang" deutlich umfangreicher aus, und dies wird zumindest theoretisch erwähnt.

Das ja lustig, das das ganze Sprachabhängig ist.....

@alhambra:

alhambra schrieb:Das ja lustig, das das ganze Sprachabhängig ist.....

Ich schätze mal, dass ca. 90% des Trainingsmaterials der aktuellen KIs englisch ist bzw. war. Das wirkt sich natürlich aus. Die aktuellen KIs können zwar ziemlich gut hin und her übersetzen, aber da besteht immer das Risiko von Fehlern oder zumindest einem Qualitätsverlust. Deshalb schreibe ich meine Fragen und Aufgabenstellungen standardmässig auf Englisch, um die maximale Antwortqualität sicherzustellen. Deutsch verwende ich i.d.R. nur, wenn um Themen mit deutschem Kontext geht.

Ich hab mich in letzter Zeit bisschen mehr mit KI beschäftigt und lasse sie für mich Coden.
Es ist einerseits faszinierend wie schnell so eine KI etwas codet, anderseits erschreckend denn ich denke der Job des Programmierers wird aussterben.

Mir ist aber aufgefallen dass die KI häufig mal etwas vergisst oder es Missverständnisse gibt.
Häufig nenne ich ihn ein Error und er meldet er hat die Syntax angepasst obwohl er mir den selben Code erneut ausgibt.

Aber das kriegt man am Ende hin.

Man muss aber trotzdem das Programm welches man coden lässt vorher planen da sonst nur Chaos entsteht.

Ich selbst werde in Zukunft selbst wohl nicht mehr coden sondern das mit KI erstellen weil es unglaublich zeitsparender ist.

Was halt schade ist, ist dass es quasi jeder mit KI kann.

Das gab es „früher“ halt nicht weil nicht jeder das Talent zum coden hat.