GigaWiper sieht bis zu dem Second wie Ransomware aus, in dem es das aber nicht mehr ist. Microsoft hat am 9. Juli 2026 eine Code-Stage-Analyse der Home windows-Hintertür veröffentlicht, und der gefälschte Verschlüsselungsbildschirm der Malware ist nur eine von mehreren Möglichkeiten, wie ein Betreiber eine Maschine zerstören kann, die bereits unter Kontrolle ist. Zuerst kann es zu Screenshots, Fernzugriff und Dateidiebstahl kommen. Der Löschvorgang erfolgt immer dann, wenn der Bediener beschließt, ihn auszulösen.

Microsoft hat eine Hintertür mit drei destruktiven Modi gefunden

Microsoft Menace Intelligence gibt an, im Oktober 2025 mit der Beobachtung kompromittierter Umgebungen begonnen zu haben, die mit destruktiven Instruments gelöscht werden. Die Ermittler fanden zwei Beispieltypen: eigenständige Wiper-Binärdateien und größere Binärdateien mit vollständiger Backdoor-Funktionalität, jeweils eine nicht entfernte ausführbare Home windows-Datei, die in Go geschrieben wurde.

Die Hintertür legt 20 numerische Befehlscodes offen, von denen einige in den von Microsoft untersuchten Beispielen unvollständig oder inaktiv erscheinen. Drei der Befehle zerstören eine Maschine, jeder auf unterschiedliche Weise.

Der erste ist ein Uncooked-Disk-Wischer. Es zählt physische Festplatten über die Home windows-Verwaltungsinstrumentation auf, identifiziert das Laufwerk, auf dem sich die Home windows-Set up befindet, entfernt Partitionsverweise von den anderen, überschreibt den Rohdatenträgerinhalt und erzwingt einen sofortigen Neustart. Eine Wiederherstellung von den betroffenen Festplatten würde im Allgemeinen saubere Backups erfordern und kann nach einem vollständigen Überschreiben und der Zerstörung der Partitionstabelle unpraktisch sein.

Die zweite führt gefälschte Ransomware aus, die auf dem Code einer älteren Sorte namens Crucio basiert. Befehl 3 generiert einen zufälligen Verschlüsselungsschlüssel und Initialisierungsvektor, verschlüsselt Dateien mit AES-CBC, löscht die Originale, benennt den Relaxation mit der Erweiterung .sweet um und ändert das Desktop-Hintergrundbild. Der Schlüssel wird nie gespeichert. Es folgt kein Lösegeldschein und keine Zahlung stellt etwas wieder her. Ein separater Befehl, Nummer 5, kann Dateien mithilfe bereitgestellter oder gespeicherter Schlüssel verschlüsseln oder entschlüsseln. Sowohl Autoren als auch Leser sollten es von der Einwegverschlüsselung von Befehl 3 unterscheiden, da beide gegensätzlichen Zwecken dienen.

Der dritte Befehl implementiert FlockWiper, einen ursprünglich in C geschriebenen Wischer, in Golang neu. Es zielt direkt auf das Home windows-Laufwerk ab und führt wiederholte Überschreibvorgänge mit mehreren Datenmustern durch. Ein vierter Befehl deaktiviert die Home windows-Wiederherstellung, ändert den Besitz und die Berechtigungen für Boot- und Kerneldateien, löscht sie und erzwingt einen Bluescreen-Zustand. Das Gerät kann danach nicht mehr regular booten.

Das Implantat kann zuschauen, bevor es abwischt

Zerstörung macht nur einen Teil dessen aus, was GigaWiper tut. Dieselbe Hintertür erfasst Screenshots von jedem aktiven Monitor, zeichnet den Bildschirm auf, während ein Benutzer arbeitet, und öffnet eine versteckte Sitzung im VNC-Stil, die die Anzeige streamt und dem Bediener Maus- und Tastatursteuerung überlässt.

Es sammelt außerdem System- und Netzwerkdetails, verwaltet laufende Prozesse und Dienste, bearbeitet die Registrierung, lädt Dateien über MinIO-Shopper-Instruments hoch und löscht Home windows-Ereignisprotokolle, um die forensische Rekonstruktion zu verlangsamen. Die Hacker Information berichteten über weitere ruhende Stubs in der Analyse von Microsoft, darunter einen Keylogger und weitere inaktive Wiper-Funktionen in den untersuchten Beispielen.

Ein Sicherheitsteam, das eine Screenshot-Routine oder eine Reside-Distant-Sitzung entdeckt, neigt dazu, Spionage zu deuten. Mit GigaWiper kann der Lesevorgang umgedreht werden, sobald ein Bediener einen Befehl mit einer anderen Nummer sendet. Nichts am frühen Verhalten der Malware deutet darauf hin, dass das Ende bevorsteht.

Die OneDrive-Persistenz verbirgt sich im Verborgenen

GigaWiper hält sich selbst am Laufen, indem es sich als Cloud-Speicher-Shopper von Microsoft ausgibt. Es schreibt einen Registrierungsschlüssel unter HKCUSOFTWAREOneDriveEnvironment und plant eine Aufgabe namens OneDrive Replace, die laut Microsoft beim Begin und etwa jede Minute danach ausgelöst wird. Wenn die Hintertür ihren Fernsteuerungskanal öffnet, versteckt sie sich laut The Hacker Information hinter einer Firewall-Regel, die nach einer echten Home windows-Komponente benannt ist, Microsoft.Home windows.CloudExperienceHost. Nichts davon bedeutet, dass OneDrive selbst kompromittiert wurde. Die Malware übernimmt bekannte Namen, um sich in die normale Home windows-Aktivität einzufügen, und ein Sicherheitsanalyst, der einen Blick auf eine Aufgabenliste wirft, hat wenig Grund, einen Prozess zu kennzeichnen, der scheinbar zu einem Dienst gehört, den Millionen von Mitarbeitern bereits ausführen.

RabbitMQ und Redis verwandeln Unternehmensinstallationen in C2

GigaWiper überspringt die lauten Webanfragen, auf die sich die meisten Schadprogramme verlassen, und nutzt stattdessen echte Enterprise-Messaging-Instruments. Microsoft hat zwei Kanäle bestätigt: RabbitMQ über AMQP zum Empfangen von Befehlen und Redis zum Zurücksenden von Standing und Ausgaben an den Operator. Eine analysierte Stichprobe nutzte einen einzelnen externen Server, 185.182.193(.)21, an zwei Ports für die beiden Dienste, wobei Broadcast-Befehle über einen RabbitMQ-Fanout-Austausch namens „All“ und gezielte Befehle über einen Themenaustausch namens „Subject“ weitergeleitet wurden.

Keines der missbrauchten Produkte weist eine Schwachstelle auf. RabbitMQ, Redis und MinIO sind legitime, weit verbreitete Technologien, und ihre Präsenz in einem Netzwerk sagt nichts über eine Kompromittierung an sich aus. Die Erkennungsfrage für ein Sicherheitsbetriebsteam wird kontextbezogen: Warum stellt ein Desktop-Endpunkt ausgehende AMQP-Verbindungen her, warum erreicht eine Workstation einen externen Redis-Server und warum benötigt ein unerwarteter Prozess überhaupt MinIO?

GigaWiper wird zusammengebaut und nicht von Grund auf neu erfunden

Die zentrale Erkenntnis von Microsoft ist architektonischer Natur. GigaWiper kombiniert einen eigenständigen Uncooked-Disk-Wiper, von Crucio abgeleitete gefälschte Ransomware und eine Golang-Neufassung von FlockWiper in einer bedienergesteuerten Plattform, anstatt es als Einzweck-Software auszuliefern. Microsoft hat außerdem ein wiederkehrendes internes Tag, „GRAT“, in den Debugpfaden von FlockWiper und den Funktionsnamen von GigaWiper, einen Hyperlink, den The Hacker Information als Beweis für eine gemeinsame Codebasis markierte, und möglicherweise eine weitere, noch nicht veröffentlichte Komponente gefunden.

Crucio selbst ist keine anonyme Sorte. Die Hacker Information führten ihren Code auf eine CISA-Meldung vom Dezember 2023 zu CyberAv3ngers zurück, einer mit dem Korps der Islamischen Revolutionsgarde des Iran verbundenen Gruppe, die in Web-exponierte Industriesteuerungen an Wasser- und Energiestandorten in den USA, Israel, Großbritannien und Irland einbrach. Das Crucio-Beispiel, das Microsoft im GigaWiper-Bericht zitiert, weist denselben Fingerabdruck auf, der in der Empfehlung aufgeführt ist, obwohl der Bericht von Microsoft keinen Anspruch auf Länderebene erhebt.

Das Muster deutet eher auf Industrialisierung als auf Erfindungen hin. Drei separate Zerstörungsfähigkeiten erfordern Zeit und Exams, um von Grund auf aufgebaut zu werden. Der Zusammenbau einer einzelnen Hintertür mit einem Befehlsmenü aus drei vorhandenen Instruments erfordert viel weniger Zeit und bietet dem Bediener Optionen, die ein Einzweck-Wischer nie bietet.

BLUERABBIT und die Frage der Namensnennung

Microsoft bestätigt direkt: Google Menace Intelligence Group und Binary Protection verfolgen GigaWiper als BLUERABBIT und lösen damit, was frühere Berichte nur aus übereinstimmenden Hashes und Infrastruktur ableiten konnten. Im Bericht von Binary Protection heißt es, man habe die Malware erstmals Mitte bis Ende März 2026 beobachtet, fünf Monate nach Beginn des Beobachtungsfensters von Microsoft im Oktober 2025, und vermutete, dass die Aktivitäten auf Unternehmen in Israel abzielten.

Binary Protection bringt BLUERABBIT unter Berufung auf die Google Menace Intelligence Group mit einem wahrscheinlichen Iran-Nexus-Aktivitätscluster in Verbindung, der zuvor mit zwei anderen Malware-Familien, BLUEWIPE und SEWERGOO, in Verbindung gebracht wurde. Der GigaWiper-Bericht von Microsoft enthält keine Zuordnung auf Länderebene. Die Verbindung zwischen GigaWiper und BLUERABBIT ist mittlerweile vom Hersteller bestätigt, aber die Zuordnungskette läuft immer noch über Binary Protection und Google Menace Intelligence Group und nicht über Microsoft. Öffentliche Quellen belegen weder eine direkte Kontrolle durch die iranische Regierung noch nennen sie eine bestimmte iranische Bedrohungsgruppe hinter der Aktivität.

Weder Microsoft noch Binary Protection haben die Anzahl der Opfer, die Namen der betroffenen Organisationen, den Erstzugriffsvektor oder den gesamten Umfang der Kampagne bekannt gegeben.

Die Malware passt in ein breiteres Muster. Die Unit 42 von Palo Alto Networks hat eine parallele Welle iranischer Wiper-Aktivitäten gegen Israel in den Jahren 2025 und 2026 verfolgt, von denen ein Großteil mit einer separaten Gruppe namens Handala Hack in Verbindung steht.

Verteidiger müssen die Hintertür vor dem Wipe stoppen

Microsoft empfiehlt eine umfassende Verteidigung. Aktivieren Sie den über die Cloud bereitgestellten Schutz, halten Sie die Endpunkterkennungssignaturen auf dem neuesten Stand und aktivieren Sie den Manipulationsschutz, damit ein Angreifer mit lokalem Zugriff die Antiviren-Instruments nicht deaktivieren kann. Beschränken Sie lokale Administratorrechte, fordern Sie eine phishing-resistente Multi-Faktor-Authentifizierung für privilegierte Konten und wechseln Sie die Anmeldeinformationen nach jeder vermuteten Kompromittierung.

Beobachten Sie geplante Aufgaben für einen Job namens OneDrive Replace, der außerhalb der normalen Softwarebereitstellung erstellt wird, insbesondere eine Aufgabe, die jede Minute ausgeführt wird oder versteckte PowerShell startet. Beobachten Sie das Netzwerk auf ausgehenden AMQP- oder Redis-Verkehr von normalen Desktops statt Servern und auf die Ausführung von MinIO-Purchasers auf Systemen, auf denen dieser normalerweise nicht ausgeführt wird. Überwachen Sie Endpunkte außerhalb eines Wartungsfensters auf unformatierten Festplattenzugriff, Änderungen an Partitionstabellen und die Verwendung von Takeown oder Icacls für Startdateien wie bootmgr oder ntoskrnl.exe.

Backups sind wichtiger als jede einzelne Erkennungsregel. Offline- oder unveränderliche Backups, separate Anmeldeinformationen für die Backup-Verwaltung und getestete Naked-Steel-Wiederherstellung bestimmen, ob eine gelöschte Maschine einen Nachmittag oder ein Viertel kostet. Ein Backup, das mit derselben kompromittierten Verwaltungsebene verbunden ist, übersteht einen zerstörerischen Vorgang möglicherweise überhaupt nicht.

Die Taktik ist alt und die Verpackung hat sich geändert

Die Idee, Zerstörung als Ransomware zu tarnen, ist nicht neu. NotPetya nutzte 2017 den gleichen Trick und gab sich als zahlungsgesteuerter Angriff aus, während er nonetheless und leise Daten auf Tausenden von Maschinen zerstörte. Was sich bei GigaWiper geändert hat, ist die Verpackung: Ein Wischer muss nicht mehr als endgültige, eigenständige Nutzlast geliefert werden. Es kann in einer multifunktionalen Hintertür untergebracht werden, die so konstruiert ist, dass sie zuerst ausspioniert und später zerstört, wann immer der Bediener dies wünscht.

Die Verschiebung ist wichtiger als jeder einzelne Befehl in der Liste von Microsoft. Früher schlossen Sicherheitsteams aus der Malware, die sie auf einem Pc fanden, auf Absichten. GigaWiper entfernt die Verknüpfung, und die Entfernung ist die wahre Geschichte, weit vor der Tarnung als Ransomware. Eine frühzeitige Eindämmung und wiederherstellbare Infrastruktur zählen heute mehr als nur zu erraten, was ein Angreifer will.

Die Massive-Information-Technologie hat zu einer Reihe von Veränderungen in unserem Leben geführt. Ein Thema, über das wir nicht sprechen möchten, ist die wachsende Sorge um den Datenschutz. Wir haben in einem früheren Artikel eine Studie zitiert, die zeigt, dass 93 % der Kunden die Marke wechseln würden, wenn Einer von ihnen schützte seine Privatsphäre besser.

Einer der Gründe dafür, dass unsere Privatsphäre im Zeitalter von Massive Information gefährdet ist, liegt darin, dass wir einen großen Teil davon in den sozialen Medien veröffentlichen. Wir haben einige der Gründe angesprochen, warum dies ein Downside sein kann in einem früheren Artikel.

Soziale Medien ermöglichen es uns, unsere Gedanken und Meinungen im Handumdrehen mit der Welt zu teilen. Aber diese spontanen Tweets oder Posts können Sie Jahre später noch einmal verfolgen. Deshalb ist es wichtig, sorgfältig darüber nachzudenken, was Sie on-line teilen, und Ihre sozialen Profile regelmäßig zu bereinigen.

Reputationsmanagement im Zeitalter von Massive Information

In der heutigen hypervernetzten Welt wissen Sie nie, wann ein potenzieller Arbeitgeber, Kunde oder sogar ein Date Sie on-line finden könnte. Einer Umfrage zufolge 70 % der Arbeitgeber überprüfen mittlerweile während des Einstellungsprozesses die sozialen Profile der Kandidaten. Und ein schlampiger digitaler Fußabdruck könnte Sie Ihren Traumjob kosten.

Wir haben über einige der Vorteile gesprochen Nutzung von Massive Information, um die Risiken benutzergenerierter Inhalte zu mindern. Diese Strategien können auf die Nutzung von Massive Information zur Verwaltung von Social-Media-Profilen wie Twitter-Konten angewendet werden.

Sogar Tweets, die zu diesem Zeitpunkt klug oder harmlos erschienen, können ein Eigenleben entwickeln und sich auf eine Weise verbreiten, die Sie nie beabsichtigt hatten. Die Karrieren von Politikern und Prominenten wurden durch das Wiederauftauchen längst vergessener Beiträge unterbrochen.

Daher ist es klug, Ihre On-line-Status zu verwalten, indem Sie gelegentlich Tweets oder Beiträge löschen, die nicht mehr das widerspiegeln, wer Sie sind oder wie Sie beruflich rüberkommen möchten.

Wann sollten Sie Tweets löschen?

Hier sind einige gute Gründe für eine gelegentliche Säuberung der sozialen Medien:

1. Sie sind nicht mehr related

Die meisten Menschen twittern über aktuelle Ereignisse, Nachrichten, Popkultur, persönliche Updates und andere aktuelle Dinge. Wenn Sie jahrelang veraltete Tweets über vergangene Developments, Beziehungen, Jobs oder Meinungen zurückblättern, kann es so aussehen, als ob Sie in der Vergangenheit feststecken. Machen Sie etwa jedes Jahr einen Feger, um die Dinge frisch zu halten.

2. Sie haben vertrauliche Informationen gepostet

Das versehentliche Tweeten von Insiderinformationen, unveröffentlichten Unternehmensnachrichten oder Kundendaten kann zu rechtlichen oder beruflichen Schwierigkeiten führen. Wenn Sie es schnell bemerken, löschen Sie es sofort.

3. Sie sind peinlich

Wir alle leben Tweet-Occasions oder teilen alberne Witze, die uns im Second intelligent erscheinen. Aber Ihre Teenagerbeiträge oder betrunkenen Karaoke-Prahlereien altern vielleicht nicht so intestine. Wenn es Sie jetzt erschaudern lässt, werden andere wahrscheinlich das Gleiche empfinden. Zeit für eine Löschung.

4. Sie wollen einen Neuanfang

Jobsuche? In die Politik einsteigen? Hatten Sie kürzlich eine große Veränderung in Ihrem Leben? Wenn Sie sich neu erfinden möchten, können Sie mit einer vollständigen Löschung Ihres sozialen Profils völlig neu anfangen.

5. Sie haben einen Troll oder Stalker

Wenn jemand Sie mit böswilligen Antworten und Erwähnungen ins Visier nimmt, reicht es möglicherweise nicht aus, ihn zu blockieren. Versuchen Sie, alle Tweets zu löschen, mit denen sie interagiert haben, sowie alle persönlichen Daten, die sie gegen Sie verwenden könnten. Melden Sie sie auch der sozialen Plattform.

6. Sie schließen ein Konto

Wenn Sie eine Plattform endgültig verlassen, stellen Sie durch das gründliche Löschen Ihrer alten Tweets sicher, dass nichts davon öffentlich bleibt. Beachten Sie jedoch, dass gelöschte Konten manchmal immer noch in den Suchergebnissen angezeigt werden.

So löschen Sie Tweets in großen Mengen

Das Durchsuchen Ihres Tweet-Archivs, um Tweets manuell zu löschen, dauert ewig. Glücklicherweise gibt es einige Abkürzungen:

Verwenden Sie ein Social-Media-Administration-Device

Instruments wie TweetDelete und TweetEraser Damit können Sie Tweets in großen Mengen löschen, basierend auf Alter, Anzahl, Schlüsselwörtern und mehr. Sie können jahrelang alte Tweets sofort löschen und gleichzeitig neuere beibehalten.

Probieren Sie Twitters native Massenlöschung aus

Twitter ermöglicht das Massenlöschen aller Tweets, die älter als ein bestimmtes Datum sind. Aber dieser Alles-oder-Nichts-Ansatz bedeutet, dass Sie auch neuere Tweets verlieren. Vorsichtig verwenden.

Aktivieren Sie das fortlaufende Löschen von Twitter-Timelines

Mit dieser Funktion zum automatischen Löschen können Sie Tweets so einstellen, dass sie sich nach einer festgelegten Anzahl von Tagen selbst zerstören. Es ist großartig, um die Privatsphäre zu wahren und zum regelmäßigen Twittern zu ermutigen. Aber Sie verlieren Tweets, die Sie behalten wollten.

Was passiert, wenn Sie Tweets löschen?

Sie fragen sich, was genau hinter den Kulissen passiert, wenn Sie Tweets löschen? Hier ist die Aufschlüsselung:

Gelöschte Tweets verschwinden von Twitter. Nach dem Löschen werden Tweets nicht mehr in Ihrem Profil, in den Feeds Ihrer Follower oder in der Twitter-Suche angezeigt. Sie werden jedoch möglicherweise immer noch kurzzeitig auf Web sites oder Instruments von Drittanbietern angezeigt, die nicht die API von Twitter verwenden.

Löschungen sind dauerhaft. Versehentlich gelöschte Tweets können weder rückgängig gemacht noch wiederhergestellt werden. Seien Sie additionally vor dem Löschen sicher!

Löschungen könnten Aufmerksamkeit erregen. Bekannte Accounts ziehen oft mehr Aufmerksamkeit auf sich, wenn sie plötzlich alte Tweets löschen. Für Persönlichkeiten des öffentlichen Lebens kann es manchmal besser sein, kontroversen Standpunkten beizustehen, als „zu versuchen, etwas zu verbergen“.

Tweets können intern noch vorhanden sein. Während Ihre gelöschten Tweets aus der öffentlichen Sicht verschwinden, bewahren Twitter und andere Technologieunternehmen die Daten aus Cybersicherheitsgründen wahrscheinlich immer noch intern auf – zumindest vorübergehend.

Google könnte gelöschte Tweets weiterhin zwischenspeichern. In den Google-Suchergebnissen können manchmal Auszüge oder Hyperlinks zu gelöschten Tweets angezeigt werden, bis sie das nächste Mal auf Twitter gecrawlt werden. Dies kommt jedoch nach einer Kontolöschung selten vor.

Dienste Dritter können Tweets speichern. Gelöschte Tweets könnten in Screenshots, in Artikeleinbettungen, auf Analyseplattformen, in Bibliotheksarchiven und an anderen Orten verbleiben, die vor dem Löschen auf die Twitter-API zugegriffen haben. Allerdings wird dies durch Datenaufbewahrungsrichtlinien und regelmäßige Systemaktualisierungen minimiert.

Wenn der Gedanke, dass zukünftige Arbeitgeber oder Termine Ihre alten Beiträge unter die Lupe nehmen, Sie ins Grübeln bringt, sollten Sie vielleicht über Alternativen zu den gängigen sozialen Netzwerken nachdenken.

Vergängliche Plattformen. Apps wie Snapchat, Instagram Tales und der Verschwinden-Modus von Fb Messenger ermöglichen das Teilen temporärer Fotos, Movies und Nachrichten, die innerhalb von 24 Stunden verschwinden. Machen Sie einfach keine Screenshots!

Anonyme Apps. Auf Plattformen wie Whisper und YikYak können Sie Gedanken austauschen und interagieren, ohne dass Benutzernamen oder Profile angehängt sind. Dies ermöglicht mehr Ehrlichkeit bei weniger Kontrolle.

Personal Gruppen und Chat-Instruments. Messaging-Apps wie WhatsApp und Sign bieten verschlüsselte Gruppenchats zum Teilen alberner Memes oder persönlicher Updates in einem vertrauenswürdigen Bereich. Auch professionelle Neighborhood-Instruments wie Slack Work stehen zur Verfügung.

Die Pflege Ihres digitalen Fußabdrucks sollte wie das Zähneputzen sein: Regelmäßige Pflege hält alles sauber! Planen Sie jedes Quartal 15 Minuten ein, um alte Tweets mit neuen Augen zu überprüfen und diejenigen zu beschneiden, die sich negativ auf Chancen oder Beziehungen auswirken könnten.

Social-Media-Instruments von Drittanbietern erleichtern das globale Massenlöschen. Die Erwägung von Alternativen wie anonymen oder kurzlebigen Plattformen kann den zukünftigen Druck verringern.

Denken Sie daran, dass es nicht realistisch ist, von jahrelanger Nutzung sozialer Medien Perfektion zu erwarten. Das Ziel besteht einfach darin, On-line-Personas zu kultivieren, die Ihr bestes Selbst repräsentieren. Mit regelmäßiger digitaler Hygiene können Sie den Second frei teilen, ohne sich um die Vergangenheit sorgen zu müssen.

FAQ

Haben Sie noch Fragen zur Bereinigung Ihrer alten Beiträge? Hier finden Sie Antworten auf einige häufig gestellte Fragen:

Verschwinden gelöschte Tweets wirklich aus dem Web?

Ja, größtenteils. Es können jedoch weiterhin Fragmente in zwischengespeicherten Versionen, Instruments von Drittanbietern, Screenshots und anderswo vorhanden sein. Mit der Zeit verblassen diese Überreste.

Können Sie einen gelöschten Tweet wiederherstellen?

Nein. Im Gegensatz zu Fb gibt es nach dem Löschen eines Tweets keine Möglichkeit, ihn wiederherzustellen. Twitter speichert gelöschte Inhalte nicht und stellt sie auch in Zukunft nicht wieder zur Verfügung.

Hinterlassen gelöschte Tweets Analysedaten?

Nein. Durch das Löschen von Tweets werden diese aus dem Twitter-System gelöscht, einschließlich Kennzahlen wie Impressionen, Engagements und mehr. Allerdings können Analyseplattformen von Drittanbietern aggregierte Metriken speichern.

Kann jemand anderes Ihre gelöschten Retweets oder Antworten noch sehen?

Nein. Wenn Sie einen Tweet löschen – auch Retweets oder Antworten – verschwindet er für alle Benutzer von Twitter. Allerdings behalten die ursprünglichen Autoren ihre ursprünglichen Tweets bei.

Zählen gelöschte Tweets zu Ihrer Gesamtzahl der Tweets?

Nein. Nach dem Löschen tragen Tweets nicht mehr zu Ihren in Profilen angezeigten Zählungen bei. Auch Ihre Medienanzahl kann sinken, wenn Sie Foto- oder Video-Tweets löschen.

Kann man auf Twitter Tweets löschen, die älter als 3200 sind?

Nein. Aufgrund von Systemeinschränkungen ermöglicht die Benutzeroberfläche jeweils nur das Massenlöschen von Tweets unter 3200. Für ältere Tweets müssen Sie Löschtools von Drittanbietern verwenden.

Warnt Twitter die Leute, wenn Sie Tweets massenhaft löschen?

Nein, Twitter benachrichtigt niemanden, wenn Sie Ihre Tweets löschen. Wenn eine große Persönlichkeit des öffentlichen Lebens plötzlich große Mengen löscht, fällt es den Followern möglicherweise immer noch auf, was Fragen aufwirft.

TDie Idee der Generative Adversarial Networks (GANs) wurde 2014 von Goodfellow und seinen Kollegen (1) vorgestellt und erfreute sich kurz darauf großer Beliebtheit im Bereich der Computervision und Bilderzeugung. Obwohl sich die KI in den letzten zehn Jahren rasant weiterentwickelt hat und immer mehr neue Algorithmen entwickelt wurden, sind die Einfachheit und Genialität dieses Konzepts immer noch äußerst beeindruckend. Heute möchte ich daher anhand des Versuchs, Wolken aus RGB-Satellitenbildern (Rot, Grün, Blau) zu entfernen, zeigen, wie leistungsfähig diese Netzwerke sein können.

Die Erstellung eines ausgewogenen, ausreichend großen und korrekt vorverarbeiteten CV-Datensatzes nimmt viel Zeit in Anspruch, daher habe ich mich entschlossen, die Möglichkeiten von Kaggle zu erkunden. Der Datensatz, der mir für diese Aufgabe am besten geeignet erschien, ist EuroSat (2), der eine offene Lizenz hat. Er umfasst 27000 beschriftete RGB-Bilder 64×64 Pixel von Sentinel-2 und ist für die Lösung des Issues der Mehrklassenklassifizierung konzipiert.

An der Klassifizierung selbst sind wir nicht interessiert, aber eines der Hauptmerkmale des EuroSat-Datensatzes ist, dass alle seine Bilder einen klaren Himmel zeigen. Das ist genau das, was wir brauchen. Wir übernehmen diesen Ansatz aus (3), verwenden diese Sentinel-2-Aufnahmen als Ziele und erstellen Eingaben, indem wir ihnen Rauschen (Wolken) hinzufügen.

Bereiten wir additionally unsere Daten vor, bevor wir tatsächlich über GANs sprechen. Zuerst müssen wir die Daten herunterladen und alle Klassen in einem Verzeichnis zusammenführen.

Der vollständige Python-Code: GitHub.

import numpy as np
import pandas as pd
import random
from os import listdir, mkdir, rename
from os.path import be part of, exists
import shutil
import datetime
import matplotlib.pyplot as plt
from highlight_text import ax_text, fig_text
from PIL import Picture
import warnings
warnings.filterwarnings('ignore')

lessons = listdir('./EuroSat')
path_target = './EuroSat/all_targets'
path_input = './EuroSat/all_inputs'
"""RUN IT ONLY ONCE TO RENAME THE FILES IN THE UNPACKED ARCHIVE"""
mkdir(path_input)
mkdir(path_target)
okay = 1
for sort in lessons:
path = be part of('./EuroSat', str(sort))
for i, f in enumerate(listdir(path)):
shutil.copyfile(be part of(path, f),
be part of(path_target, f))
rename(be part of(path_target, f), be part of(path_target, f'{okay}.jpg'))
okay += 1

Der zweite wichtige Schritt ist die Erzeugung von Rauschen. Während Sie verschiedene Ansätze verwenden können, z. B. das zufällige Ausblenden einiger Pixel oder das Hinzufügen von Gaußschem Rauschen, möchte ich in diesem Artikel etwas Neues für mich ausprobieren – Perlin-Rauschen. Es wurde in den 80er Jahren von Ken Perlin (4) bei der Entwicklung filmischer Raucheffekte erfunden. Diese Artwork von Rauschen wirkt im Vergleich zu normalem Zufallsrauschen organischer. Lassen Sie es mich einfach beweisen.

def generate_perlin_noise(width, top, scale, octaves, persistence, lacunarity):
noise = np.zeros((top, width))
for i in vary(top):
for j in vary(width):
noise(i)(j) = pnoise2(i / scale,
j / scale,
octaves=octaves,
persistence=persistence,
lacunarity=lacunarity,
repeatx=width,
repeaty=top,
base=0)
return noise
def normalize_noise(noise):
min_val = noise.min()
max_val = noise.max()
return (noise - min_val) / (max_val - min_val)
def generate_clouds(width, top, base_scale, octaves, persistence, lacunarity):
clouds = np.zeros((top, width))
for octave in vary(1, octaves + 1):
scale = base_scale / octave
layer = generate_perlin_noise(width, top, scale, 1, persistence, lacunarity)
clouds += layer * (persistence ** octave)
clouds = normalize_noise(clouds)
return clouds
def overlay_clouds(picture, clouds, alpha=0.5):
clouds_rgb = np.stack((clouds) * 3, axis=-1)
picture = picture.astype(float) / 255.0
clouds_rgb = clouds_rgb.astype(float)
blended = picture * (1 - alpha) + clouds_rgb * alpha
blended = (blended * 255).astype(np.uint8)
return blended

width, top = 64, 64
octaves = 12 #variety of noise layers mixed
persistence = 0.5 #decrease persistence reduces the amplitude of higher-frequency octaves
lacunarity = 2 #larger lacunarity will increase the frequency of higher-frequency octaves
for i in vary(len(listdir(path_target))):
base_scale = random.uniform(5,120) #noise frequency
alpha = random.uniform(0,1) #transparency
clouds = generate_clouds(width, top, base_scale, octaves, persistence, lacunarity)
img = np.asarray(Picture.open(be part of(path_target, f'{i+1}.jpg')))
picture = Picture.fromarray(overlay_clouds(img,clouds, alpha))
picture.save(be part of(path_input,f'{i+1}.jpg'))
print(f'Processed {i+1}/{len(listdir(path_target))}')

idx = np.random.randint(27000)
fig,ax = plt.subplots(1,2)
ax(0).imshow(np.asarray(Picture.open(be part of(path_target, f'{idx}.jpg'))))
ax(1).imshow(np.asarray(Picture.open(be part of(path_input, f'{idx}.jpg'))))
ax(0).set_title("Goal")
ax(0).axis('off')
ax(1).set_title("Enter")
ax(1).axis('off')
plt.present()

Wie Sie oben sehen können, sind die Wolken auf den Bildern sehr realistisch, sie haben unterschiedliche „Dichte“ und Texturen und ähneln den echten.

Wenn Sie Perlin-Rauschen genauso faszinierend finden wie ich, finden Sie hier ein wirklich cooles Video dazu, wie dieses Rauschen in der GameDev-Branche eingesetzt werden kann:

Da wir jetzt über einen gebrauchsfertigen Datensatz verfügen, sprechen wir über GANs.

Um diesen Gedanken besser zu veranschaulichen, stellen wir uns vor, Sie reisen durch Südostasien und brauchen dringend einen Kapuzenpullover, weil es draußen zu kalt ist. Auf dem nächsten Straßenmarkt finden Sie ein kleines Geschäft mit Markenkleidung. Der Verkäufer bringt Ihnen einen schönen Kapuzenpullover zum Anprobieren und sagt, es sei von der bekannten Marke ExpensiveButNotWorthIt. Sie sehen ihn sich genauer an und kommen zu dem Schluss, dass es sich offensichtlich um eine Fälschung handelt. Der Verkäufer sagt: „Second mal, ich habe den ECHTEN.“ Er kommt mit einem anderen Kapuzenpullover zurück, der noch mehr wie der Markenpullover aussieht, aber dennoch eine Fälschung ist. Nach mehreren Versuchen dieser Artwork bringt Ihnen der Verkäufer eine nicht zu unterscheidende Kopie des legendären ExpensiveButNotWorthIt und Sie kaufen ihn bereitwillig. So funktionieren die GANs im Grunde!

Im Fall von GANs nennt man Sie Diskriminator (D). Das Ziel eines Diskriminators ist es, zwischen einem echten und einem gefälschten Objekt zu unterscheiden oder die Aufgabe der binären Klassifizierung zu lösen. Der Verkäufer wird Generator (G) genannt, da er versucht, eine hochwertige Fälschung zu erzeugen. Diskriminator und Generator werden unabhängig voneinander trainiert, um sich gegenseitig zu übertreffen. Daher erhalten wir am Ende eine hochwertige Fälschung.

Der Trainingsprozess sieht ursprünglich folgendermaßen aus:

1. Beispiel für Eingangsrauschen (in unserem Fall Bilder mit Wolken).
2. Geben Sie G das Rauschen weiter und sammeln Sie die Vorhersage.
3. Berechnen Sie den D-Verlust, indem Sie zwei Vorhersagen einholen, eine für die Ausgabe von G und eine für die realen Daten.
4. Aktualisieren Sie die Gewichte von D.
5. Probieren Sie das Eingangsrauschen erneut aus.
6. Geben Sie G das Rauschen weiter und sammeln Sie die Vorhersage.
7. Berechnen Sie den G-Verlust, indem Sie seine Vorhersage in D einspeisen.
8. Aktualisieren Sie die Gewichte von G.

Mit anderen Worten können wir eine Wertfunktion V(G,D) definieren:

wo wir den Begriff minimieren wollen log(1-D(G(z))) um G zu trainieren und zu maximieren log D(x) um D zu trainieren (in dieser Notation x – reale Datenprobe und z – Rauschen).

Versuchen wir jetzt, es in PyTorch zu implementieren!

Im Originalartikel sprechen die Autoren von der Verwendung von Multilayer Perceptron (MLP); es wird auch oft einfach als ANN bezeichnet, aber ich möchte einen etwas komplizierteren Ansatz ausprobieren – ich möchte die UNet-Architektur (5) als Generator und ResNet (6) als Diskriminator verwenden. Dies sind beides bekannte CNN-Architekturen, daher werde ich sie hier nicht erklären (lassen Sie mich in den Kommentaren wissen, ob ich einen separaten Artikel schreiben soll).

Lasst sie uns bauen. Diskriminator:

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.useful as F
from torch.utils.knowledge import Dataset, DataLoader
from torchvision import transforms
from torch.utils.knowledge import Subset

class ResidualBlock(nn.Module):
def __init__(self, in_channels, out_channels, stride = 1, downsample = None):
tremendous(ResidualBlock, self).__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size = 3, stride = stride, padding = 1),
nn.BatchNorm2d(out_channels),
nn.ReLU())
self.conv2 = nn.Sequential(
nn.Conv2d(out_channels, out_channels, kernel_size = 3, stride = 1, padding = 1),
nn.BatchNorm2d(out_channels))
self.downsample = downsample
self.relu = nn.ReLU()
self.out_channels = out_channels
def ahead(self, x):
residual = x
out = self.conv1(x)
out = self.conv2(out)
if self.downsample:
residual = self.downsample(x)
out += residual
out = self.relu(out)
return out
class ResNet(nn.Module):
def __init__(self, block=ResidualBlock, all_connections=(3,4,6,3)):
tremendous(ResNet, self).__init__()
self.inputs = 16
self.conv1 = nn.Sequential(
nn.Conv2d(3, 16, kernel_size = 3, stride = 1, padding = 1),
nn.BatchNorm2d(16),
nn.ReLU()) #16x64x64
self.maxpool = nn.MaxPool2d(kernel_size = 2, stride = 2) #16x32x32
self.layer0 = self.makeLayer(block, 16, all_connections(0), stride = 1) #connections = 3, form: 16x32x32
self.layer1 = self.makeLayer(block, 32, all_connections(1), stride = 2)#connections = 4, form: 32x16x16
self.layer2 = self.makeLayer(block, 128, all_connections(2), stride = 2)#connections = 6, form: 1281x8x8
self.layer3 = self.makeLayer(block, 256, all_connections(3), stride = 2)#connections = 3, form: 256x4x4
self.avgpool = nn.AvgPool2d(4, stride=1)
self.fc = nn.Linear(256, 1)
def makeLayer(self, block, outputs, connections, stride=1):
downsample = None
if stride != 1 or self.inputs != outputs:
downsample = nn.Sequential(
nn.Conv2d(self.inputs, outputs, kernel_size=1, stride=stride),
nn.BatchNorm2d(outputs),
)
layers = ()
layers.append(block(self.inputs, outputs, stride, downsample))
self.inputs = outputs
for i in vary(1, connections):
layers.append(block(self.inputs, outputs))
return nn.Sequential(*layers)
def ahead(self, x):
x = self.conv1(x)
x = self.maxpool(x)
x = self.layer0(x)
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.avgpool(x)
x = x.view(-1, 256)
x = self.fc(x).flatten()
return F.sigmoid(x)

Generator:

class DoubleConv(nn.Module):
def __init__(self, in_channels, out_channels):
tremendous(DoubleConv, self).__init__()
self.double_conv = nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True),
nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True)
)
def ahead(self, x):
return self.double_conv(x)
class UNet(nn.Module):
def __init__(self):
tremendous().__init__()
self.conv_1 = DoubleConv(3, 32) # 32x64x64
self.pool_1 = nn.MaxPool2d(kernel_size=2, stride=2) # 32x32x32
self.conv_2 = DoubleConv(32, 64)  #64x32x32
self.pool_2 = nn.MaxPool2d(kernel_size=2, stride=2) #64x16x16
self.conv_3 = DoubleConv(64, 128)  #128x16x16
self.pool_3 = nn.MaxPool2d(kernel_size=2, stride=2) #128x8x8
self.conv_4 = DoubleConv(128, 256)  #256x8x8
self.pool_4 = nn.MaxPool2d(kernel_size=2, stride=2) #256x4x4
self.conv_5 = DoubleConv(256, 512)  #512x2x2
#DECODER
self.upconv_1 = nn.ConvTranspose2d(512, 256, kernel_size=2, stride=2) #256x4x4
self.conv_6 = DoubleConv(512, 256) #256x4x4
self.upconv_2 = nn.ConvTranspose2d(256, 128, kernel_size=2, stride=2) #128x8x8
self.conv_7 = DoubleConv(256, 128)  #128x8x8
self.upconv_3 = nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2) #64x16x16
self.conv_8 = DoubleConv(128, 64)  #64x16x16
self.upconv_4 = nn.ConvTranspose2d(64, 32, kernel_size=2, stride=2) #32x32x32
self.conv_9 = DoubleConv(64, 32)  #32x32x32
self.output = nn.Conv2d(32, 3, kernel_size = 3, stride = 1, padding = 1) #3x64x64
def ahead(self, batch):
conv_1_out = self.conv_1(batch)
conv_2_out = self.conv_2(self.pool_1(conv_1_out))
conv_3_out = self.conv_3(self.pool_2(conv_2_out))
conv_4_out = self.conv_4(self.pool_3(conv_3_out))
conv_5_out = self.conv_5(self.pool_4(conv_4_out))
conv_6_out = self.conv_6(torch.cat((self.upconv_1(conv_5_out), conv_4_out), dim=1))
conv_7_out = self.conv_7(torch.cat((self.upconv_2(conv_6_out), conv_3_out), dim=1))
conv_8_out = self.conv_8(torch.cat((self.upconv_3(conv_7_out), conv_2_out), dim=1))
conv_9_out = self.conv_9(torch.cat((self.upconv_4(conv_8_out), conv_1_out), dim=1))
output = self.output(conv_9_out)
return F.sigmoid(output)

Jetzt müssen wir unsere Daten in Practice/Take a look at aufteilen und sie in einen Torch-Datensatz packen:

class dataset(Dataset):
def __init__(self, batch_size, images_paths, targets, img_size = 64):
self.batch_size = batch_size
self.img_size = img_size
self.images_paths = images_paths
self.targets = targets
self.len = len(self.images_paths) // batch_size
self.remodel = transforms.Compose((
transforms.ToTensor(),
))
self.batch_im = (self.images_paths(idx * self.batch_size:(idx + 1) * self.batch_size) for idx in vary(self.len))
self.batch_t = (self.targets(idx * self.batch_size:(idx + 1) * self.batch_size) for idx in vary(self.len))
def __getitem__(self, idx):
pred = torch.stack((
self.remodel(Picture.open(be part of(path_input,file_name)))
for file_name in self.batch_im(idx)
))
goal = torch.stack((
self.remodel(Picture.open(be part of(path_target,file_name)))
for file_name in self.batch_im(idx)
))
return pred, goal
def __len__(self):
return self.len

Perfekt. Es ist Zeit, die Trainingsschleife zu schreiben. Bevor wir das tun, definieren wir unsere Verlustfunktionen und den Optimierer:

gadget = torch.gadget("cuda" if torch.cuda.is_available() else "cpu")
batch_size = 64
num_epochs = 15
learning_rate_D = 1e-5
learning_rate_G = 1e-4
discriminator = ResNet()
generator = UNet()
bce = nn.BCEWithLogitsLoss()
l1loss = nn.L1Loss()
optimizer_D = optim.Adam(discriminator.parameters(), lr=learning_rate_D)
optimizer_G = optim.Adam(generator.parameters(), lr=learning_rate_G)
scheduler_D = optim.lr_scheduler.StepLR(optimizer_D, step_size=10, gamma=0.1)
scheduler_G = optim.lr_scheduler.StepLR(optimizer_G, step_size=10, gamma=0.1)

Wie Sie sehen, unterscheiden sich diese Verluste von dem Bild mit dem GAN-Algorithmus. Insbesondere habe ich L1Loss hinzugefügt. Die Idee ist, dass wir nicht einfach ein zufälliges Bild aus Rauschen erzeugen, sondern die meisten Informationen aus der Eingabe behalten und nur das Rauschen entfernen möchten. Der G-Verlust beträgt additionally:

G_Verlust = log(1 − D(G(z))) + 𝝀 |G(z)-y|

statt nur

G_Verlust = log(1 − D(G(z)))

𝝀 ist ein beliebiger Koeffizient, der zwei Komponenten der Verluste ausgleicht.

Lassen Sie uns abschließend die Daten aufteilen, um den Trainingsprozess zu starten:

test_ratio, train_ratio = 0.3, 0.7
num_test = int(len(listdir(path_target))*test_ratio)
num_train = int((int(len(listdir(path_target)))-num_test))
img_size = (64, 64)
print("Variety of prepare samples:", num_train)
print("Variety of check samples:", num_test)
random.seed(231)
train_idxs = np.array(random.pattern(vary(num_test+num_train), num_train))
masks = np.ones(num_train+num_test, dtype=bool)
masks(train_idxs) = False
photos = {}
options = random.pattern(listdir(path_input),num_test+num_train)
targets = random.pattern(listdir(path_target),num_test+num_train)
random.Random(231).shuffle(options)
random.Random(231).shuffle(targets)
train_input_img_paths = np.array(options)(train_idxs)
train_target_img_path = np.array(targets)(train_idxs)
test_input_img_paths = np.array(options)(masks)
test_target_img_path = np.array(targets)(masks)
train_loader = dataset(batch_size=batch_size, img_size=img_size, images_paths=train_input_img_paths, targets=train_target_img_path)
test_loader = dataset(batch_size=batch_size, img_size=img_size, images_paths=test_input_img_paths, targets=test_target_img_path)

Jetzt können wir unsere Trainingsschleife ausführen:

train_loss_G, train_loss_D, val_loss_G, val_loss_D = (), (), (), ()
all_loss_G, all_loss_D = (), ()
best_generator_epoch_val_loss, best_discriminator_epoch_val_loss = -np.inf, -np.inf
for epoch in vary(num_epochs):
discriminator.prepare()
generator.prepare()
discriminator_epoch_loss, generator_epoch_loss = 0, 0
for inputs, targets in train_loader:
inputs, true = inputs, targets
'''1. Coaching the Discriminator (ResNet)'''
optimizer_D.zero_grad()
pretend = generator(inputs).detach()
pred_fake = discriminator(pretend).to(gadget)
loss_fake = bce(pred_fake, torch.zeros(batch_size, gadget=gadget))
pred_real = discriminator(true).to(gadget)
loss_real = bce(pred_real, torch.ones(batch_size, gadget=gadget))
loss_D = (loss_fake+loss_real)/2
loss_D.backward()
optimizer_D.step()
discriminator_epoch_loss += loss_D.merchandise()
all_loss_D.append(loss_D.merchandise())
'''2. Coaching the Generator (UNet)'''
optimizer_G.zero_grad()
pretend = generator(inputs)
pred_fake = discriminator(pretend).to(gadget)
loss_G_bce = bce(pred_fake, torch.ones_like(pred_fake, gadget=gadget))
loss_G_l1 = l1loss(pretend, targets)*100
loss_G = loss_G_bce + loss_G_l1
loss_G.backward()
optimizer_G.step()
generator_epoch_loss += loss_G.merchandise()
all_loss_G.append(loss_G.merchandise())
discriminator_epoch_loss /= len(train_loader)
generator_epoch_loss /= len(train_loader)
train_loss_D.append(discriminator_epoch_loss)
train_loss_G.append(generator_epoch_loss)
discriminator.eval()
generator.eval()
discriminator_epoch_val_loss, generator_epoch_val_loss = 0, 0
with torch.no_grad():
for inputs, targets in test_loader:
inputs, targets = inputs, targets
pretend = generator(inputs)
pred = discriminator(pretend).to(gadget)
loss_G_bce = bce(pretend, torch.ones_like(pretend, gadget=gadget))
loss_G_l1 = l1loss(pretend, targets)*100
loss_G = loss_G_bce + loss_G_l1
loss_D = bce(pred.to(gadget), torch.zeros(batch_size, gadget=gadget))
discriminator_epoch_val_loss += loss_D.merchandise()
generator_epoch_val_loss += loss_G.merchandise()
discriminator_epoch_val_loss /= len(test_loader)
generator_epoch_val_loss /= len(test_loader)
val_loss_D.append(discriminator_epoch_val_loss)
val_loss_G.append(generator_epoch_val_loss)
print(f"------Epoch ({epoch+1}/{num_epochs})------nTrain Loss D: {discriminator_epoch_loss:.4f}, Val Loss D: {discriminator_epoch_val_loss:.4f}")
print(f'Practice Loss G: {generator_epoch_loss:.4f}, Val Loss G: {generator_epoch_val_loss:.4f}')
if discriminator_epoch_val_loss > best_discriminator_epoch_val_loss:
discriminator_epoch_val_loss = best_discriminator_epoch_val_loss
torch.save(discriminator.state_dict(), "discriminator.pth")
if generator_epoch_val_loss > best_generator_epoch_val_loss:
generator_epoch_val_loss = best_generator_epoch_val_loss
torch.save(generator.state_dict(), "generator.pth")
#scheduler_D.step()
#scheduler_G.step()
fig, ax = plt.subplots(1,3)
ax(0).imshow(np.transpose(inputs.numpy()(7), (1,2,0)))
ax(1).imshow(np.transpose(targets.numpy()(7), (1,2,0)))
ax(2).imshow(np.transpose(pretend.detach().numpy()(7), (1,2,0)))
plt.present()

Nachdem der Code fertig ist, können wir die Verluste plotten. Dieser Code wurde teilweise übernommen von diese coole Webseite:

from matplotlib.font_manager import FontProperties
background_color = '#001219'
font = FontProperties(fname='LexendDeca-VariableFont_wght.ttf')
fig, ax = plt.subplots(1, 2, figsize=(16, 9))
fig.set_facecolor(background_color)
ax(0).set_facecolor(background_color)
ax(1).set_facecolor(background_color)
ax(0).plot(vary(len(all_loss_G)), all_loss_G, colour='#bc6c25', lw=0.5) 
ax(1).plot(vary(len(all_loss_D)), all_loss_D, colour='#00b4d8', lw=0.5)
ax(0).scatter(
(np.array(all_loss_G).argmax(), np.array(all_loss_G).argmin()),
(np.array(all_loss_G).max(), np.array(all_loss_G).min()),
s=30, colour='#bc6c25',
)
ax(1).scatter(
(np.array(all_loss_D).argmax(), np.array(all_loss_D).argmin()),
(np.array(all_loss_D).max(), np.array(all_loss_D).min()),
s=30, colour='#00b4d8',
)
ax_text(
np.array(all_loss_G).argmax()+60, np.array(all_loss_G).max()+0.1,
f'{spherical(np.array(all_loss_G).max(),1)}',
fontsize=13, colour='#bc6c25',
font=font,
ax=ax(0)
)
ax_text(
np.array(all_loss_G).argmin()+60, np.array(all_loss_G).min()-0.1,
f'{spherical(np.array(all_loss_G).min(),1)}',
fontsize=13, colour='#bc6c25',
font=font,
ax=ax(0)
)
ax_text(
np.array(all_loss_D).argmax()+60, np.array(all_loss_D).max()+0.01,
f'{spherical(np.array(all_loss_D).max(),1)}',
fontsize=13, colour='#00b4d8',
font=font,
ax=ax(1)
)
ax_text(
np.array(all_loss_D).argmin()+60, np.array(all_loss_D).min()-0.005,
f'{spherical(np.array(all_loss_D).min(),1)}',
fontsize=13, colour='#00b4d8',
font=font,
ax=ax(1)
)
for i in vary(2):
ax(i).tick_params(axis='x', colours='white')
ax(i).tick_params(axis='y', colours='white')
ax(i).spines('left').set_color('white') 
ax(i).spines('backside').set_color('white') 
ax(i).set_xlabel('Epoch', colour='white', fontproperties=font, fontsize=13)
ax(i).set_ylabel('Loss', colour='white', fontproperties=font, fontsize=13)
ax(0).set_title('Generator', colour='white', fontproperties=font, fontsize=18)
ax(1).set_title('Discriminator', colour='white', fontproperties=font, fontsize=18)
plt.savefig('Loss.jpg')
plt.present()
# ax(0).set_axis_off()
# ax(1).set_axis_off()