Intelligente Fortschrittsanzeige ETA-Berechnung

In vielen Anwendungen gibt es einen Fortschrittsbalken für einen Dateidownload, eine Komprimierungsaufgabe, eine Suche usw. Wir alle verwenden häufig Fortschrittsbalken, um Benutzer darüber zu informieren, dass etwas passiert. Und wenn wir einige Details wissen, wie viel Arbeit geleistet wurde und wie viel noch zu tun ist, können wir sogar eine Zeitschätzung abgeben, häufig durch Extrapolation der Zeit, die benötigt wird, um das aktuelle Fortschrittsniveau zu erreichen.

_{(Quelle: jameslao.com )}

Wir haben aber auch Programme gesehen, bei denen diese Time Left "ETA" -Anzeige nur komisch schlecht ist. Es wird behauptet, dass eine Dateikopie in 20 Sekunden fertig sein wird. Eine Sekunde später heißt es, dass es 4 Tage dauern wird, und dann flackert es erneut, um 20 Minuten zu sein. Es ist nicht nur nicht hilfreich, es ist auch verwirrend! Der Grund, warum die ETA so unterschiedlich ist, ist, dass die Fortschrittsrate selbst variieren kann und die Mathematik des Programmierers übermäßig empfindlich sein kann.

Apple umgeht dies, indem es nur genaue Vorhersagen vermeidet und nur vage Schätzungen gibt! _{(Quelle: autodesk.com )}

Das ist auch ärgerlich, habe ich Zeit für eine kurze Pause oder wird meine Aufgabe in 2 weiteren Sekunden erledigt sein? Wenn die Vorhersage zu unscharf ist, ist es sinnlos, überhaupt eine Vorhersage zu treffen.

Einfache aber falsche Methoden

Als ETA-Berechnung für den ersten Durchgang machen wir wahrscheinlich alle nur eine Funktion, als ob p der Bruchteil des Prozentsatzes ist, der bereits durchgeführt wurde, und t die Zeit ist, die bisher benötigt wurde. Wir geben t * (1-p) / p als Schätzung von aus Wie lange wird es dauern, bis es fertig ist? Dieses einfache Verhältnis funktioniert "OK", aber es ist auch schrecklich, besonders am Ende der Berechnung. Wenn Ihre langsame Download-Geschwindigkeit eine Kopie langsam über Nacht voranschreitet und schließlich am Morgen etwas einsetzt und die Kopie mit 100-facher Geschwindigkeit mit voller Geschwindigkeit beginnt, kann Ihre ETA bei 90% fertig "1 Stunde" und 10 Sekunden sagen später sind Sie bei 95% und die ETA wird "30 Minuten" sagen, was eindeutig eine peinlich schlechte Vermutung ist. In diesem Fall ist "10 Sekunden" eine viel, viel, viel bessere Schätzung.

In diesem Fall können Sie die Berechnung so ändern , dass zur Schätzung der ETA die aktuelle Geschwindigkeit und nicht die Durchschnittsgeschwindigkeit verwendet wird. Sie nehmen die durchschnittliche Download- oder Abschlussrate der letzten 10 Sekunden und verwenden diese Rate, um zu projizieren, wie lange der Abschluss dauern wird. Dies ist im vorherigen Beispiel für das Herunterladen über Nacht, das am Ende beschleunigt wurde, recht gut, da es am Ende sehr gute Schätzungen für die endgültige Fertigstellung liefert. Dies hat jedoch immer noch große Probleme. Es führt dazu, dass Ihre ETA stark abprallt, wenn sich Ihre Rate über einen kurzen Zeitraum schnell ändert, und Sie erhalten das "in 20 Sekunden erledigt, in 2 Stunden erledigt, in 2 Sekunden erledigt, in 30 erledigt." Minuten "schnelle Anzeige der Programmierschande.

Die eigentliche Frage:

Was ist der beste Weg, um eine geschätzte Zeit für die Fertigstellung einer Aufgabe zu berechnen, wenn man den zeitlichen Verlauf der Berechnung berücksichtigt? Ich suche keine Links zu GUI-Toolkits oder Qt-Bibliotheken. Ich frage nach dem Algorithmus , um die vernünftigsten und genauesten Schätzungen der Fertigstellungszeit zu generieren.

Haben Sie Erfolg mit mathematischen Formeln gehabt? Eine Art Mittelwertbildung, vielleicht unter Verwendung des Mittelwerts der Rate über 10 Sekunden mit der Rate über 1 Minute mit der Rate über 1 Stunde? Eine Art künstliche Filterung wie "Wenn meine neue Schätzung zu stark von der vorherigen Schätzung abweicht, verringern Sie sie, lassen Sie sie nicht zu stark abprallen"? Eine Art ausgefallene Verlaufsanalyse, bei der Sie den Fortschritt gegenüber dem Zeitfortschritt integrieren, um die Standardabweichung der Rate zu ermitteln und nach Abschluss statistische Fehlermetriken zu erhalten?

Was haben Sie versucht und was funktioniert am besten?

Ursprüngliche Antwort

Das Unternehmen, das diese Site erstellt hat, erstellt anscheinend ein Planungssystem, das diese Frage im Zusammenhang mit dem Schreiben von Code durch Mitarbeiter beantwortet. Die Art und Weise, wie es funktioniert, ist mit der Monte-Carlo-Simulation der Zukunft basierend auf der Vergangenheit.

Anhang: Erklärung von Monte Carlo

So würde dieser Algorithmus in Ihrer Situation funktionieren:

Sie modellieren Ihre Aufgabe als eine Folge von Mikrotasks, beispielsweise 1000 davon. Angenommen, Sie haben eine Stunde später 100 davon abgeschlossen. Jetzt führen Sie die Simulation für die verbleibenden 900 Schritte aus, indem Sie 90 abgeschlossene Mikrotasks zufällig auswählen, ihre Zeiten addieren und mit 10 multiplizieren. Hier haben Sie eine Schätzung; Wiederholen Sie N-mal und Sie haben N Schätzungen für die verbleibende Zeit. Beachten Sie, dass der Durchschnitt zwischen diesen Schätzungen etwa 9 Stunden beträgt - hier keine Überraschungen. Wenn Sie dem Benutzer die resultierende Verteilung präsentieren, teilen Sie ihm ehrlich die Chancen mit, z. B. "Mit einer Wahrscheinlichkeit von 90% dauert dies weitere 3 bis 15 Stunden".

Dieser Algorithmus liefert per Definition ein vollständiges Ergebnis, wenn die betreffende Aufgabe als eine Reihe unabhängiger, zufälliger Mikrotasks modelliert werden kann. Eine bessere Antwort erhalten Sie nur, wenn Sie wissen, wie die Aufgabe von diesem Modell abweicht: Beispielsweise haben Installer normalerweise eine Taskliste zum Herunterladen / Entpacken / Installieren, und die Geschwindigkeit für eine kann die andere nicht vorhersagen.

Anhang: Vereinfachung von Monte Carlo

Ich bin kein Statistik-Guru, aber ich denke, wenn Sie sich die Simulation bei dieser Methode genauer ansehen, wird immer eine Normalverteilung als Summe einer großen Anzahl unabhängiger Zufallsvariablen zurückgegeben. Daher müssen Sie es überhaupt nicht ausführen. Tatsächlich müssen Sie nicht einmal alle abgeschlossenen Zeiten speichern, da Sie nur die Summe und die Summe ihrer Quadrate benötigen.

In vielleicht nicht sehr normaler Notation,

sigma = sqrt ( sum_of_times_squared-sum_of_times^2 )
scaling = 900/100          // that is (totalSteps - elapsedSteps) / elapsedSteps
lowerBound = sum_of_times*scaling - 3*sigma*sqrt(scaling)
upperBound = sum_of_times*scaling + 3*sigma*sqrt(scaling)

Damit können Sie die Meldung ausgeben, dass das Ding ab sofort mit einer festen Wahrscheinlichkeit zwischen [lowerBound, UpperBound] endet (sollte ungefähr 95% betragen, aber ich habe wahrscheinlich einen konstanten Faktor übersehen).

Folgendes habe ich gefunden: funktioniert gut! Für die ersten 50% der Aufgabe nehmen Sie an, dass die Rate konstant ist, und extrapolieren sie. Die Zeitvorhersage ist sehr stabil und springt nicht viel.

Sobald Sie 50% erreicht haben, wechseln Sie die Berechnungsstrategie. Sie nehmen den Bruchteil der noch zu erledigenden Aufgabe (1-p), blicken dann in der Vergangenheit auf einen Verlauf Ihres eigenen Fortschritts zurück und ermitteln (durch binäre Suche und lineare Interpolation), wie lange Sie für die letzte Aufgabe gebraucht haben (1) -p) Prozentsatz und verwenden Sie diesen als Abschluss Ihrer Zeitschätzung.

Wenn Sie jetzt zu 71% fertig sind, haben Sie noch 29% übrig. Sie blicken in Ihre Geschichte zurück und stellen fest, wie lange es her ist, dass Sie (71-29 = 42%) fertig sind. Melden Sie diese Zeit als Ihre ETA.

Dies ist natürlich anpassungsfähig. Wenn Sie X Arbeit haben, wird nur die Zeit angezeigt, die für die X Arbeit benötigt wurde. Am Ende, wenn Sie zu 99% fertig sind, werden nur sehr frische, sehr aktuelle Daten für die Schätzung verwendet.

Es ist natürlich nicht perfekt, aber es ändert sich reibungslos und ist am Ende besonders genau, wenn es am nützlichsten ist.

Obwohl alle Beispiele gültig sind, hielt ich es für den speziellen Fall der verbleibenden Zeit zum Herunterladen für eine gute Idee, vorhandene Open-Source-Projekte zu betrachten, um zu sehen, was sie tun.

Soweit ich sehen kann, kann Mozilla Firefox die verbleibende Zeit am besten abschätzen.

Mozilla Firefox

Firefox verfolgt die letzte Schätzung für die verbleibende Zeit und führt mithilfe dieser und der aktuellen Schätzung für die verbleibende Zeit eine Glättungsfunktion für die Zeit durch. Den ETA-Code finden Sie hier . Dies verwendet eine 'Geschwindigkeit', die zuvor hier berechnet wurde und ein geglätteter Durchschnitt der letzten 10 Messwerte ist.

Dies ist ein wenig komplex, um es zu paraphrasieren:

• Nehmen Sie einen geglätteten Durchschnitt der Geschwindigkeit, basierend auf 90% der vorherigen Geschwindigkeit und 10% der neuen Geschwindigkeit.
• Mit dieser geglätteten Durchschnittsgeschwindigkeit wird die geschätzte verbleibende Zeit berechnet.
• Verwenden Sie diese geschätzte verbleibende verbleibende Zeit und die zuvor geschätzte verbleibende verbleibende Zeit, um eine neue geschätzte verbleibende verbleibende Zeit zu erstellen (um ein Springen zu vermeiden).

Google Chrome

Chrome scheint überall herumzuspringen, und der Code zeigt dies .

Eine Sache, die ich mit Chrome mag, ist, wie sie die verbleibende Zeit formatieren. Für> 1 Stunde steht "1 Stunde übrig". Für <1 Stunde steht "59 Minuten übrig". Für <1 Minute steht "52 Sekunden übrig".

Wie es formatiert ist, können Sie hier sehen

DownThemAll! Manager

Es wird nichts Kluges verwendet, was bedeutet, dass die ETA überall herumspringt.

Siehe den Code hier

pySmartDL (ein Python-Downloader)

Nimmt die durchschnittliche ETA der letzten 30 ETA-Berechnungen. Klingt nach einem vernünftigen Weg.

Den Code finden Sie hier /blob/916f2592db326241a2bf4d8f2e0719c58b71e385/pySmartDL/pySmartDL.py#L651)

Übertragung

Gibt in den meisten Fällen eine ziemlich gute ETA (außer zu Beginn, wie zu erwarten).

Verwendet einen Glättungsfaktor in den letzten 5 Messungen, ähnlich wie Firefox, aber nicht ganz so komplex. Grundsätzlich ähnlich zu Goolis Antwort.

Siehe den Code hier

Normalerweise verwende ich einen exponentiellen gleitenden Durchschnitt , um die Geschwindigkeit einer Operation mit einem Glättungsfaktor von beispielsweise 0,1 zu berechnen, und verwende diesen, um die verbleibende Zeit zu berechnen. Auf diese Weise haben alle gemessenen Geschwindigkeiten Einfluss auf die aktuelle Geschwindigkeit, aber neuere Messungen haben viel mehr Auswirkungen als in der fernen Vergangenheit.

Im Code würde es ungefähr so ​​aussehen:

alpha = 0.1 # smoothing factor
...
speed = (speed * (1 - alpha)) + (currentSpeed * alpha)

Wenn Ihre Aufgaben eine einheitliche Größe haben, ist currentSpeeddies einfach die Zeit, die für die Ausführung der letzten Aufgabe benötigt wurde. Wenn die Aufgaben unterschiedliche Größen haben und Sie wissen, dass eine Aufgabe doppelt so lang sein soll wie eine andere, können Sie die Zeit, die zur Ausführung der Aufgabe benötigt wurde, durch ihre relative Größe teilen, um die aktuelle Geschwindigkeit zu erhalten. Mit können speedSie die verbleibende Zeit berechnen, indem Sie sie mit der Gesamtgröße der verbleibenden Aufgaben multiplizieren (oder nur mit ihrer Anzahl, wenn die Aufgaben einheitlich sind).

Hoffentlich ist meine Erklärung klar genug, es ist ein bisschen spät am Tag.

In bestimmten Fällen, wenn Sie dieselbe Aufgabe regelmäßig ausführen müssen, ist es möglicherweise eine gute Idee, vergangene Abschlusszeiten als Durchschnitt zu verwenden.

Zum Beispiel habe ich eine Anwendung, die die iTunes-Mediathek über ihre COM-Schnittstelle lädt. Die Größe einer bestimmten iTunes-Mediathek nimmt in Bezug auf die Anzahl der Elemente von Start zu Start im Allgemeinen nicht dramatisch zu. In diesem Beispiel ist es daher möglicherweise möglich, die letzten drei Ladezeiten und Laderaten zu verfolgen und dann gegen diese und zu mitteln Berechnen Sie Ihre aktuelle ETA.

Dies wäre weitaus genauer als eine sofortige Messung und wahrscheinlich auch konsistenter.

Diese Methode hängt jedoch davon ab, dass die Größe der Aufgabe den vorherigen relativ ähnlich ist. Dies würde also nicht für eine Dekomprimierungsmethode oder etwas anderes funktionieren, bei dem ein bestimmter Bytestrom die zu zerkleinernden Daten sind.

Nur meine $ 0,02

Zunächst hilft es, einen laufenden gleitenden Durchschnitt zu generieren. Dies gewichtet neuere Ereignisse stärker.

Bewahren Sie dazu eine Reihe von Samples auf (zirkulärer Puffer oder Liste), jeweils ein Paar von Fortschritt und Zeit. Bewahren Sie die letzten N Sekunden der Proben auf. Generieren Sie dann einen gewichteten Durchschnitt der Stichproben:

totalProgress += (curSample.progress - prevSample.progress) * scaleFactor
totalTime += (curSample.time - prevSample.time) * scaleFactor

Dabei skaliert scaleFactor in der Vergangenheit linear von 0 ... 1 als inverse Funktion der Zeit (wodurch neuere Proben schwerer gewichtet werden). Mit dieser Gewichtung können Sie natürlich herumspielen.

Am Ende können Sie die durchschnittliche Änderungsrate erhalten:

 averageProgressRate = (totalProgress / totalTime);

Sie können dies verwenden, um die ETA zu ermitteln, indem Sie den verbleibenden Fortschritt durch diese Zahl dividieren.

Während dies Ihnen eine gute Trendzahl gibt, haben Sie ein anderes Problem - Jitter. Wenn sich Ihre Fortschrittsrate aufgrund natürlicher Schwankungen etwas bewegt (es ist laut) - z. B. wenn Sie dies zum Schätzen von Dateidownloads verwenden -, werden Sie feststellen, dass das Rauschen leicht dazu führen kann, dass Ihre ETA herumspringt, insbesondere wenn Es ist ziemlich weit in der Zukunft (einige Minuten oder länger).

Um zu vermeiden, dass Jitter Ihre ETA zu stark beeinflusst, möchten Sie, dass diese durchschnittliche Änderungsrate langsam auf Aktualisierungen reagiert. Eine Möglichkeit, dies zu erreichen, besteht darin, einen zwischengespeicherten Wert von durchschnittlichProgressRate beizubehalten. Anstatt ihn sofort auf die gerade berechnete Trendzahl zu aktualisieren, simulieren Sie ihn als schweres physisches Objekt mit Masse und wenden eine simulierte 'Kraft' zu langsam an Bewegen Sie es in Richtung der Trendzahl. Mit Masse hat es ein wenig Trägheit und ist weniger wahrscheinlich von Jitter betroffen.

Hier ist ein grobes Beispiel:

// desiredAverageProgressRate is computed from the weighted average above
// m_averageProgressRate is a member variable also in progress units/sec
// lastTimeElapsed = the time delta in seconds (since last simulation) 
// m_averageSpeed is a member variable in units/sec, used to hold the 
// the velocity of m_averageProgressRate


const float frictionCoeff = 0.75f;
const float mass = 4.0f;
const float maxSpeedCoeff = 0.25f;

// lose 25% of our speed per sec, simulating friction
m_averageSeekSpeed *= pow(frictionCoeff, lastTimeElapsed); 

float delta = desiredAvgProgressRate - m_averageProgressRate;

// update the velocity
float oldSpeed = m_averageSeekSpeed;
float accel = delta / mass;    
m_averageSeekSpeed += accel * lastTimeElapsed;  // v += at

// clamp the top speed to 25% of our current value
float sign = (m_averageSeekSpeed > 0.0f ? 1.0f : -1.0f);
float maxVal = m_averageProgressRate * maxSpeedCoeff;
if (fabs(m_averageSeekSpeed) > maxVal)
{
 m_averageSeekSpeed = sign * maxVal;
}

// make sure they have the same sign
if ((m_averageSeekSpeed > 0.0f) == (delta > 0.0f))
{
 float adjust = (oldSpeed + m_averageSeekSpeed) * 0.5f * lastTimeElapsed;

 // don't overshoot.
 if (fabs(adjust) > fabs(delta))
 {
    adjust = delta;
            // apply damping
    m_averageSeekSpeed *= 0.25f;
 }

 m_averageProgressRate += adjust;
}    

Ihre Frage ist gut. Wenn das Problem in diskrete Einheiten aufgeteilt werden kann, funktioniert eine genaue Berechnung oft am besten. Leider ist dies möglicherweise nicht der Fall, selbst wenn Sie 50 Komponenten installieren, die jeweils 2% betragen, aber eine davon kann massiv sein. Eine Sache, mit der ich mäßigen Erfolg hatte, ist es, die CPU und die Festplatte zu takten und eine anständige Schätzung basierend auf Beobachtungsdaten zu geben. Wenn Sie wissen, dass bestimmte Prüfpunkte wirklich Punkt x sind, können Sie Umgebungsfaktoren (Netzwerk, Festplattenaktivität, CPU-Auslastung) korrigieren. Diese Lösung ist jedoch nicht allgemeiner Natur, da sie auf Beobachtungsdaten beruht. Die Verwendung von Zusatzdaten wie der Größe der U / min-Datei hat mir geholfen, meine Fortschrittsbalken genauer zu machen, aber sie sind niemals kugelsicher.

Einheitliche Mittelung

Der einfachste Ansatz wäre, die verbleibende Zeit linear vorherzusagen:

t_rem := t_spent ( n - prog ) / prog

Wo t_remist die vorhergesagte ETA, t_spentist die seit Beginn der Operation verstrichene Zeit, progdie Anzahl der Mikrotasks, die aus ihrer vollen Menge erledigt wurden n. Zu erklären - nkann die Anzahl der zu verarbeitenden Zeilen in einer Tabelle oder die Anzahl der zu kopierenden Dateien sein.

Bei dieser Methode ohne Parameter muss man sich keine Gedanken über die Feinabstimmung des Exponenten der Dämpfung machen. Der Kompromiss ist eine schlechte Anpassung an eine sich ändernde Fortschrittsrate, da alle Stichproben den gleichen Beitrag zur Schätzung leisten, während nur die jüngsten Stichproben mehr Gewicht haben sollten als die alten, was uns dazu führt

Exponentielle Glättung der Rate

bei der die Standardtechnik darin besteht, die Fortschrittsrate durch Mittelung vorheriger Punktmessungen zu schätzen:

rate := 1 / (n * dt); { rate equals normalized progress per unit time }
if prog = 1 then      { if first microtask just completed }
    rate_est := rate; { initialize the estimate }
else
begin
    weight   := Exp( - dt / DECAY_T );
    rate_est := rate_est * weight + rate * (1.0 - weight);
    t_rem    := (1.0 - prog / n) / rate_est;
end;

Dabei dtbezeichnet die Dauer der zuletzt abgeschlossenen Mikrotask und entspricht der Zeit, die seit der vorherigen Fortschrittsaktualisierung vergangen ist. Beachten Sie, dass dies weightkeine Konstante ist und entsprechend der Zeitspanne angepasst werden muss, in der rateeine bestimmte Geschwindigkeit beobachtet wurde. Je länger wir eine bestimmte Geschwindigkeit beobachtet haben, desto höher ist der exponentielle Abfall der vorherigen Messungen. Die Konstante DECAY_Tbezeichnet die Zeitdauer, während der das Gewicht einer Probe um den Faktor e abnimmt . SPWorley selbst schlug eine ähnliche Änderung zu Goolis Vorschlag vor, obwohl er ihn auf den falschen Begriff anwendete. Ein exponentieller Durchschnitt für äquidistante Messungen ist:

Avg_e(n) = Avg_e(n-1) * alpha + m_n * (1 - alpha)

aber was ist, wenn die Stichproben nicht gleich weit voneinander entfernt sind, wie dies bei Zeiten in einem typischen Fortschrittsbalken der Fall ist? Berücksichtigen Sie, dass alphaoben nur ein empirischer Quotient ist, dessen wahrer Wert ist:

alpha = Exp( - lambda * dt ),

Wo lambdaist der Parameter des Exponentialfensters und dtder Änderungsbetrag seit der vorherigen Stichprobe, bei dem es sich nicht um Zeit, sondern um einen linearen und additiven Parameter handeln muss. alphaist für äquidistante Messungen konstant, variiert jedoch mit dt.

Markieren Sie, dass diese Methode auf einer vordefinierten Zeitkonstante basiert und nicht zeitlich skalierbar ist. Mit anderen Worten, wenn der exakt gleiche Prozess gleichmäßig um einen konstanten Faktor verlangsamt wird, wird dieses ratenbasierte Filter proportional empfindlicher gegenüber Signalschwankungen, da es bei jedem Schritt weightverringert wird. Wenn wir jedoch eine von der Zeitskala unabhängige Glättung wünschen, sollten wir darüber nachdenken

Exponentielle Glättung der Langsamkeit

Dies ist im Wesentlichen die Glättung der Rate, die auf den Kopf gestellt wurde, mit der zusätzlichen Vereinfachung einer Konstante, weightweil sie progin äquidistanten Schritten zunimmt:

slowness := n * dt;   { slowness is the amount of time per unity progress }
if prog = 1 then      { if first microtask just completed }
    slowness_est := slowness; { initialize the estimate }
else
begin
    weight       := Exp( - 1 / (n * DECAY_P ) );
    slowness_est := slowness_est * weight + slowness * (1.0 - weight);
    t_rem        := (1.0 - prog / n) * slowness_est;
end;

Die dimensionslose Konstante DECAY_Pbezeichnet die normalisierte Fortschrittsdifferenz zwischen zwei Proben, deren Gewichte im Verhältnis von eins zu e stehen . Mit anderen Worten, diese Konstante bestimmt die Breite des Glättungsfensters im Fortschrittsbereich und nicht im Zeitbereich. Diese Technik ist daher unabhängig von der Zeitskala und hat eine konstante räumliche Auflösung.

Weitere Forschung: Adaptive exponentielle Glättung

Sie können jetzt die verschiedenen Algorithmen der adaptiven exponentiellen Glättung ausprobieren . Denken Sie nur daran, es eher auf Langsamkeit als auf Bewertung anzuwenden .

Ich wünschte immer, diese Dinge würden mir eine Reichweite verraten. Wenn es heißt: "Diese Aufgabe wird höchstwahrscheinlich zwischen 8 und 30 Minuten erledigt sein", dann habe ich eine Vorstellung davon, welche Art von Pause ich machen soll. Wenn es überall herumspringt, bin ich versucht, es zu beobachten, bis es sich beruhigt hat, was eine große Zeitverschwendung ist.

Ich habe versucht und vereinfacht Ihre "einfach" / "falsch" / "OK" Formel und es funktioniert am besten für mich:

t / p - t

In Python:

>>> done=0.3; duration=10; "time left: %i" % (duration / done - duration)
'time left: 23'

Das spart eine Operation im Vergleich zu (dur * (1-done) / done). Und in dem von Ihnen beschriebenen Randfall spielt es kaum eine Rolle, den Dialog 30 Minuten lang zu ignorieren, nachdem Sie die ganze Nacht gewartet haben.

Beim Vergleich dieser einfachen Methode mit der von Transmission verwendeten Methode stellte ich fest, dass sie bis zu 72% genauer ist.

Ich schwitze nicht, es ist ein sehr kleiner Teil einer Anwendung. Ich sage ihnen, was los ist, und lasse sie etwas anderes tun.