Dass das Testen unseres Codes ein entscheidender und wesentlicher Bestandteil des Lebenszyklus für die Lebensweise der Softwareentwicklung ist. Dies ist vielleicht noch wichtiger, wenn wir über KI- und ML -Systeme diskutieren, bei denen eine inhärente Unsicherheit und ein halluzinatorisches Ingredient von Anfang an bereits eingebacken werden.

In diesem allgemeinen Testframework kann der Testcode, der sich je nach aktuellem Datum oder Uhrzeit unterschiedlich verhält, ein realer Kopfschmerz sein. Wie überprüfen Sie die Logik zuverlässig, die nur um Mitternacht auslöst, relative Daten („vor 2 Stunden“) berechnet oder knifflige Situationen wie Schaltjahre oder Monatsends behandelt? Das manuelle Verspotten von Pythons DateTime-Modul kann umständlich und fehleranfällig sein.

Wenn Sie jemals damit gerungen haben, sind Sie nicht allein. Aber was wäre, wenn Sie einfach … die Zeit anhalten könnten? Oder sogar in Ihren Exams durchlaufen?

Genau das ermöglicht die Freezegun -Bibliothek Sie. Es ist eine elegante Lösung für ein gemeinsames Testproblem, aber viele erfahrene Python -Entwickler haben noch nie davon gehört.

Freezegun Ermöglicht es Ihren Python -Exams, bestimmte Momente in der Zeit zu simulieren, indem Sie die Module für DateTime, Datum, Uhrzeit und Pendelspython verspotten. Es ist einfach zu bedienen, aber leistungsfähig, um deterministische und zuverlässige Exams für zeitempfindlichen Code zu erstellen.

Warum ist Freezegun so hilfreich?

1. Determinismus. Dies ist der Hauptvorteil von Freezegun. Exams mit Zeit werden völlig vorhersehbar. Ausführen von DateTime.Now () In einem gefrorenen Block gibt den gleichen gefrorenen Zeitstempel zurück, wodurch die durch Millisekundenunterschiede oder Datumsüberschreitungen während der Testausführung verursachten Exams beseitigt werden.
2. Einfachheit. Im Vergleich zum manuelles Patchen datetime.now oder verwenden unittest.mockFreezegun ist oft viel sauberer und benötigt weniger Boilerplate -Code, insbesondere wenn die Zeit vorübergehend geändert wird.
3. Zeitreisen. Simuliert einfach bestimmte Daten und Zeiten – Vergangenheit, Gegenwart oder Zukunft. Dies ist entscheidend für das Testen von Randfällen, wie z. B. die Verarbeitung von Jahresende, Sekunden, Sekunden, Tageslichtsparenübergänge oder lediglich an bestimmte Ereignisse gebundene Logik.
4. Relative Zeitprüfung. Testerfunktionen, die die relativen Zeiten berechnen (z. B. „in 3 Tagen“), indem die Zeit gefriert und Zeitstempel im Verhältnis zu diesem gefrorenen Second erstellt werden.
5. Ticken Sie tock. Freezegun ermöglicht die Zeit zum Vormarsch („Tick“) aus dem gefrorenen Second innerhalb eines Exams, der perfekt zum Testen von Zeitüberschreitungen, Dauern oder Sequenzen zeitabhängiger Ereignisse geeignet ist.

Hoffentlich habe ich Sie davon überzeugt, dass Freezegun eine wertvolle Ergänzung Ihrer Python -Toolbox sein könnte. Lassen Sie es uns in Aktion sehen, indem wir einige Beispielcode -Snippets durchsehen.

Einrichten einer Entwicklerumgebung

Lassen Sie uns vorher jedoch eine Entwicklungsumgebung einrichten, mit der wir experimentieren können. Ich benutze dafür Miniconda, aber Sie können jedes Device verwenden, mit dem Sie vertraut sind.

Ich bin ein Home windows -Benutzer, aber ich entwickle oft mit WSL2 Ubuntu für Home windows, was ich hier tun werde.

Der gesamte Code, den ich zeige, sollte unter Home windows oder Unix-ähnlichen Betriebssystemen gleich intestine funktionieren.

# Create and activate a brand new dev surroundings
#
(base) $ conda create -n freezegun python=3.12 -y
(base) $ conda activate freezegun

Jetzt können wir die verbleibenden notwendigen Bibliotheken installieren.

(freezegun) $ pip set up freezegun jupyter

Ich werde Jupyter Pocket book verwenden, um meinen Code auszuführen. Geben Sie mit jupyter pocket book in Ihre Eingabeaufforderung. Sie sollten ein Jupyter -Notizbuch in Ihrem Browser geöffnet sehen. Wenn das nicht automatisch passiert, werden Sie wahrscheinlich eine Bildschirminformationen nach dem feststellen jupyter pocket book Befehl. Nahe unten finden Sie eine URL zum Kopieren und Einfügen in Ihren Browser, um das Jupyter -Notizbuch zu starten.

Ihre URL wird anders sein als meine, aber sie sollte ungefähr so ​​aussehen:-

http://127.0.0.1:8888/tree?token=3b9f7bd07b6966b41b68e2350721b2d0b6f388d248cc69da

Abgesehen von: Der Code, den ich in meinen folgenden Beispielen zeige, nutzt die Python stark behaupten Befehl. Wenn Sie diese Funktion zuvor noch nicht begegnet sind oder in Python nicht viel Unit -Exams durchgeführt haben, wird Assert verwendet, um zu testen, ob eine Bedingung wahr ist, und wenn dies nicht der Fall ist, erhöht sie eine AssertionError.Dies hilft bei der Entwicklung von Themen und wird häufig zum Debugieren und Validieren von Annahmen im Code verwendet.

Beispiel 1: Primary Time Erezing mit einem Dekorateur

Die häufigste Artwork, Freezegun zu verwenden, ist über seinen DekorateurAnwesend @Freeze_time, Das ermöglicht es Ihnen „Setzen Sie“ eine bestimmte Tageszeit, um verschiedene zeitbezogene Funktionen zu testen.

import datetime
from freezegun import freeze_time

def get_greeting():
    now = datetime.datetime.now()
    print(f"  Inside get_greeting(), now = {now}") # Added print
    if now.hour < 12:
        return "Good morning!"
    elif 12 <= now.hour < 18:
        return "Good afternoon!"
    else:
        return "Good night!"

# Take a look at the morning greeting
@freeze_time("2023-10-27 09:00:00")
def test_morning_greeting():
    print("Operating test_morning_greeting:")
    greeting = get_greeting()
    print(f"  -> Obtained greeting: '{greeting}'")
    assert greeting == "Good morning!"

# Take a look at the night greeting
@freeze_time("2023-10-27 21:30:00")
def test_evening_greeting():
    print("nRunning test_evening_greeting:")
    greeting = get_greeting()
    print(f"  -> Obtained greeting: '{greeting}'")
    assert greeting == "Good night!"

# Run the checks
test_morning_greeting()
test_evening_greeting()
print("nBasic decorator checks handed!")

# --- Failure State of affairs ---
# What occurs if we do not freeze time?
print("n--- Operating with out freeze_time (may fail relying on precise time) ---")
def test_morning_greeting_unfrozen():
    print("Operating test_morning_greeting_unfrozen:")
    greeting = get_greeting()
    print(f"  -> Obtained greeting: '{greeting}'")
    # This assertion is now unreliable! It will depend on once you run the code.
    attempt:
        assert greeting == "Good morning!" 
        print("  (Handed by probability)")
    besides AssertionError:
        print("  (Failed as anticipated - time wasn't 9 AM)")

test_morning_greeting_unfrozen()

Und die Ausgabe.

Operating test_morning_greeting:
  Inside get_greeting(), now = 2023-10-27 09:00:00
  -> Obtained greeting: 'Good morning!'

Operating test_evening_greeting:
  Inside get_greeting(), now = 2023-10-27 21:30:00
  -> Obtained greeting: 'Good night!'

Primary decorator checks handed!

--- Operating with out freeze_time (may fail relying on precise time) ---
Operating test_morning_greeting_unfrozen:
  Inside get_greeting(), now = 2025-04-16 15:00:37.363367
  -> Obtained greeting: 'Good afternoon!'
  (Failed as anticipated - time wasn't 9 AM)

Beispiel 2: Primary Time Evezing mit einem Kontextmanager

Erstellen Sie einen „Block“ der gefrorenen Zeit.

import datetime
from freezegun import freeze_time

def process_batch_job():
    start_time = datetime.datetime.now()
    # Simulate work
    end_time = datetime.datetime.now() # In actuality, time would cross
    print(f"  Inside job: Begin={start_time}, Finish={end_time}") # Added print
    return (start_time, end_time)

def test_job_timestamps_within_frozen_block():
    print("nRunning test_job_timestamps_within_frozen_block:")
    frozen_time_str = "2023-11-15 10:00:00"
    with freeze_time(frozen_time_str):
        print(f"  Getting into frozen block at {frozen_time_str}")
        begin, finish = process_batch_job()
        
        print(f"  Asserting begin == finish: {begin} == {finish}")
        assert begin == finish
        print(f"  Asserting begin == frozen time: {begin} == {datetime.datetime(2023, 11, 15, 10, 0, 0)}")
        assert begin == datetime.datetime(2023, 11, 15, 10, 0, 0)
        print("  Assertions inside block handed.")
        
    print("  Exited frozen block.")
    now_outside = datetime.datetime.now()
    print(f"  Time exterior block: {now_outside} (needs to be actual time)")
    # This assertion simply exhibits time is unfrozen, worth will depend on actual time
    assert now_outside != datetime.datetime(2023, 11, 15, 10, 0, 0)

test_job_timestamps_within_frozen_block()
print("nContext supervisor check handed!")

Die Ausgabe.

 Operating test_job_timestamps_within_frozen_block:
 Getting into frozen block at 2023-11-15 10:00:00
 Inside job: Begin=2023-11-15 10:00:00, Finish=2023-11-15 10:00:00
 Asserting begin == finish: 2023-11-15 10:00:00 == 2023-11-15 10:00:00
 Asserting begin == frozen time: 2023-11-15 10:00:00 == 2023-11-15 10:00:00
 Assertions inside block handed.
 Exited frozen block.
 Time exterior block: 2025-04-16 15:10:15.231632 (needs to be actual time)

 Context supervisor check handed!

Beispiel 3: Die Zeit mit Tick vorantreiben

Simulieren Sie die Zeit innerhalb eines gefrorenen Zeitraums.

import datetime
import time
from freezegun import freeze_time

def check_if_event_expired(event_timestamp, expiry_duration_seconds):
    now = datetime.datetime.now()
    expired = now > event_timestamp + datetime.timedelta(seconds=expiry_duration_seconds)
    print(f"  Checking expiry: Now={now}, Occasion={event_timestamp}, ExpiresAt={event_timestamp + datetime.timedelta(seconds=expiry_duration_seconds)} -> Expired={expired}")
    return expired

# --- Guide ticking utilizing context supervisor ---
def test_event_expiry_manual_tick():
    print("nRunning test_event_expiry_manual_tick:")

    with freeze_time("2023-10-27 12:00:00") as freezer:
        event_time_in_freeze = datetime.datetime.now()
        expiry_duration = 60
        print(f"  Occasion created at: {event_time_in_freeze}")

        print("  Checking instantly after creation:")
        assert not check_if_event_expired(event_time_in_freeze, expiry_duration)

        # Advance time by 61 seconds
        delta_to_tick = datetime.timedelta(seconds=61)
        print(f"  Ticking ahead by {delta_to_tick}...")
        freezer.tick(delta=delta_to_tick)

        print(f"  Time after ticking: {datetime.datetime.now()}")
        print("  Checking after ticking:")
        assert check_if_event_expired(event_time_in_freeze, expiry_duration)

        print("  Guide tick check completed.")

# --- Failure State of affairs ---
@freeze_time("2023-10-27 12:00:00")  # No tick=True or guide tick
def test_event_expiry_fail_without_tick():
    print("n--- Operating test_event_expiry_fail_without_tick (EXPECT ASSERTION ERROR) ---")
    event_time = datetime.datetime.now()
    expiry_duration = 60
    print(f"  Occasion created at: {event_time}")

    # Simulate work or ready - with out tick, time would not advance!
    time.sleep(0.1)

    print(f"  Time after simulated wait: {datetime.datetime.now()}")
    print("  Checking expiry (incorrectly, time did not transfer):")
    attempt:
        # This could ideally be True, however will probably be False with out ticking
        assert check_if_event_expired(event_time, expiry_duration)
    besides AssertionError:
        print("  AssertionError: Occasion didn't expire, as anticipated with out tick.")
    print("  Failure situation completed.")

# Run each checks
test_event_expiry_manual_tick()
test_event_expiry_fail_without_tick()

Dies gibt Folgendes aus.

Operating test_event_expiry_manual_tick:
  Occasion created at: 2023-10-27 12:00:00
  Checking instantly after creation:
  Checking expiry: Now=2023-10-27 12:00:00, Occasion=2023-10-27 12:00:00, ExpiresAt=2023-10-27 12:01:00 -> Expired=False
  Ticking ahead by 0:01:01...
  Time after ticking: 2023-10-27 12:01:01
  Checking after ticking:
  Checking expiry: Now=2023-10-27 12:01:01, Occasion=2023-10-27 12:00:00, ExpiresAt=2023-10-27 12:01:00 -> Expired=True
  Guide tick check completed.

--- Operating test_event_expiry_fail_without_tick (EXPECT ASSERTION ERROR) ---
  Occasion created at: 2023-10-27 12:00:00
  Time after simulated wait: 2023-10-27 12:00:00
  Checking expiry (incorrectly, time did not transfer):
  Checking expiry: Now=2023-10-27 12:00:00, Occasion=2023-10-27 12:00:00, ExpiresAt=2023-10-27 12:01:00 -> Expired=False
  AssertionError: Occasion didn't expire, as anticipated with out tick.
  Failure situation completed.

Beispiel 4: Testen der relativen Daten

Freezegun sorgt für eine stabile „Zeit“ -Logik.

import datetime
from freezegun import freeze_time

def format_relative_time(timestamp):
    now = datetime.datetime.now()
    delta = now - timestamp
    
    rel_time_str = ""
    if delta.days > 0:
        rel_time_str = f"{delta.days} days in the past"
    elif delta.seconds >= 3600:
        hours = delta.seconds // 3600
        rel_time_str = f"{hours} hours in the past"
    elif delta.seconds >= 60:
        minutes = delta.seconds // 60
        rel_time_str = f"{minutes} minutes in the past"
    else:
        rel_time_str = "simply now"
    print(f"  Formatting relative time: Now={now}, Timestamp={timestamp} -> '{rel_time_str}'")
    return rel_time_str

@freeze_time("2023-10-27 15:00:00")
def test_relative_time_formatting():
    print("nRunning test_relative_time_formatting:")
    
    # Occasion occurred 2 days and three hours in the past relative to frozen time
    past_event = datetime.datetime(2023, 10, 25, 12, 0, 0)
    assert format_relative_time(past_event) == "2 days in the past"

    # Occasion occurred 45 minutes in the past
    recent_event = datetime.datetime.now() - datetime.timedelta(minutes=45)
    assert format_relative_time(recent_event) == "45 minutes in the past"

    # Occasion occurred simply now
    current_event = datetime.datetime.now() - datetime.timedelta(seconds=10)
    assert format_relative_time(current_event) == "simply now"
    
    print("  Relative time checks handed!")

test_relative_time_formatting()

# --- Failure State of affairs ---
print("n--- Operating relative time with out freeze_time (EXPECT FAILURE) ---")
def test_relative_time_unfrozen():
    # Use the identical previous occasion timestamp
    past_event = datetime.datetime(2023, 10, 25, 12, 0, 0) 
    print(f"  Testing with past_event = {past_event}")
    # It will examine towards the *precise* present time, not Oct twenty seventh, 2023
    formatted_time = format_relative_time(past_event)
    attempt:
        assert formatted_time == "2 days in the past" 
    besides AssertionError:
        # The precise distinction will probably be a lot bigger!
        print(f"  AssertionError: Anticipated '2 days in the past', however obtained '{formatted_time}'. Failed as anticipated.")

test_relative_time_unfrozen()

Die Ausgabe.

Operating test_relative_time_formatting:
  Formatting relative time: Now=2023-10-27 15:00:00, Timestamp=2023-10-25 12:00:00 -> '2 days in the past'
  Formatting relative time: Now=2023-10-27 15:00:00, Timestamp=2023-10-27 14:15:00 -> '45 minutes in the past'
  Formatting relative time: Now=2023-10-27 15:00:00, Timestamp=2023-10-27 14:59:50 -> 'simply now'
  Relative time checks handed!

--- Operating relative time with out freeze_time (EXPECT FAILURE) ---
  Testing with past_event = 2023-10-25 12:00:00
  Formatting relative time: Now=2023-10-27 12:00:00, Timestamp=2023-10-25 12:00:00 -> '2 days in the past'

Beispiel 5: Umgang mit bestimmten Daten (Ende des Monats)

Testkantenfälle wie Schaltjahre zuverlässig.

import datetime
from freezegun import freeze_time

def is_last_day_of_month(check_date):
    next_day = check_date + datetime.timedelta(days=1)
    is_last = next_day.month != check_date.month
    print(f"  Checking if {check_date} is final day of month: Subsequent day={next_day}, IsLast={is_last}")
    return is_last

print("nRunning particular date logic checks:")

@freeze_time("2023-02-28") # Non-leap 12 months
def test_end_of_february_non_leap():
    as we speak = datetime.date.as we speak()
    assert is_last_day_of_month(as we speak) is True

@freeze_time("2024-02-28") # Bissextile year
def test_end_of_february_leap_not_yet():
     as we speak = datetime.date.as we speak()
     assert is_last_day_of_month(as we speak) is False # Feb twenty ninth exists

@freeze_time("2024-02-29") # Bissextile year - final day
def test_end_of_february_leap_actual():
    as we speak = datetime.date.as we speak()
    assert is_last_day_of_month(as we speak) is True

@freeze_time("2023-12-31")
def test_end_of_year():
    as we speak = datetime.date.as we speak()
    assert is_last_day_of_month(as we speak) is True

test_end_of_february_non_leap()
test_end_of_february_leap_not_yet()
test_end_of_february_leap_actual()
test_end_of_year()
print("Particular date logic checks handed!")



#
# Output
#


Operating particular date logic checks:
Checking if 2023-02-28 is final day of month: Subsequent day=2023-03-01, IsLast=True
Checking if 2024-02-28 is final day of month: Subsequent day=2024-02-29, IsLast=False
Checking if 2024-02-29 is final day of month: Subsequent day=2024-03-01, IsLast=True
Checking if 2023-12-31 is final day of month: Subsequent day=2024-01-01, IsLast=True
pecific date logic checks handed!

Beispiel 6: Zeitzonen

Testen Sie Zeitzone-bewusstes Code korrekt und bearbeiten Sie Offsets und Übergänge wie BST/GMT.

# Requires Python 3.9+ for zoneinfo or `pip set up pytz` for older variations
import datetime
from freezegun import freeze_time
attempt:
    from zoneinfo import ZoneInfo # Python 3.9+
besides ImportError:
    from pytz import timezone as ZoneInfo # Fallback for older Python/pytz

def get_local_and_utc_time():
    # Assume native timezone is Europe/London for this instance
    local_tz = ZoneInfo("Europe/London")
    now_utc = datetime.datetime.now(datetime.timezone.utc)
    now_local = now_utc.astimezone(local_tz)
    print(f"  Getting instances: UTC={now_utc}, Native={now_local} ({now_local.tzname()})")
    return now_local, now_utc

# Freeze time as 9 AM UTC. London is UTC+1 in summer time (BST). Oct 27 is BST.
@freeze_time("2023-10-27 09:00:00", tz_offset=0) # tz_offset=0 means the frozen time string IS UTC
def test_time_in_london_bst():
    print("nRunning test_time_in_london_bst:")
    local_time, utc_time = get_local_and_utc_time()
    assert utc_time.hour == 9
    assert local_time.hour == 10 # London is UTC+1 on this date
    assert local_time.tzname() == "BST" 

# Freeze time as 9 AM UTC. Use December twenty seventh, which is GMT (UTC+0)
@freeze_time("2023-12-27 09:00:00", tz_offset=0)
def test_time_in_london_gmt():
    print("nRunning test_time_in_london_gmt:")
    local_time, utc_time = get_local_and_utc_time()
    assert utc_time.hour == 9
    assert local_time.hour == 9 # London is UTC+0 on this date
    assert local_time.tzname() == "GMT"

test_time_in_london_bst()
test_time_in_london_gmt()
print("nTimezone checks handed!")

#
# Output
#

 Operating test_time_in_london_bst:
 Getting instances: UTC=2023-10-27 09:00:00+00:00, Native=2023-10-27 10:00:00+01:00 (BST)

 Operating test_time_in_london_gmt:
 Getting instances: UTC=2023-12-27 09:00:00+00:00, Native=2023-12-27 09:00:00+00:00 (GMT)

 Timezone checks handed!

Beispiel 7: Explizite Zeitreisen mit der Funktion move_to

Springen Sie zwischen spezifischen Zeitpunkten in einem einzelnen Take a look at für komplexe zeitliche Sequenzen.

import datetime
from freezegun import freeze_time

class ReportGenerator:
    def __init__(self):
        self.creation_time = datetime.datetime.now()
        self.knowledge = {"standing": "pending", "generated_at": None}
        print(f"  Report created at {self.creation_time}")

    def generate(self):
        self.knowledge("standing") = "generated"
        self.knowledge("generated_at") = datetime.datetime.now()
        print(f"  Report generated at {self.knowledge('generated_at')}")

    def get_status_update(self):
        now = datetime.datetime.now()
        if self.knowledge("standing") == "generated":
            time_since_generation = now - self.knowledge("generated_at")
            standing = f"Generated {time_since_generation.seconds} seconds in the past."
        else:
            time_since_creation = now - self.creation_time
            standing = f"Pending for {time_since_creation.seconds} seconds."
        print(f"  Standing replace at {now}: '{standing}'")
        return standing

def test_report_lifecycle():
    print("nRunning test_report_lifecycle:")
    with freeze_time("2023-11-01 10:00:00") as freezer:
        report = ReportGenerator()
        assert report.knowledge("standing") == "pending"
        
        # Verify standing after 5 seconds
        target_time = datetime.datetime(2023, 11, 1, 10, 0, 5)
        print(f"  Transferring time to {target_time}")
        freezer.move_to(target_time)
        assert report.get_status_update() == "Pending for five seconds."

        # Generate the report at 10:01:00
        target_time = datetime.datetime(2023, 11, 1, 10, 1, 0)
        print(f"  Transferring time to {target_time} and producing report")
        freezer.move_to(target_time)
        report.generate()
        assert report.knowledge("standing") == "generated"
        assert report.get_status_update() == "Generated 0 seconds in the past."

        # Verify standing 30 seconds after technology
        target_time = datetime.datetime(2023, 11, 1, 10, 1, 30)
        print(f"  Transferring time to {target_time}")
        freezer.move_to(target_time)
        assert report.get_status_update() == "Generated 30 seconds in the past."
        
    print("  Complicated lifecycle check handed!")

test_report_lifecycle()

# --- Failure State of affairs ---
def test_report_lifecycle_fail_forgot_move():
    print("n--- Operating lifecycle check (FAIL - forgot move_to) ---")
    with freeze_time("2023-11-01 10:00:00") as freezer:
        report = ReportGenerator()
        assert report.knowledge("standing") == "pending"
        
        # We INTEND to test standing after 5 seconds, however FORGET to maneuver time
        print(f"  Checking standing (time continues to be {datetime.datetime.now()})")
        # freezer.move_to("2023-11-01 10:00:05") # <-- Forgotten!
        attempt:
            assert report.get_status_update() == "Pending for five seconds."
        besides AssertionError as e:
            print(f"  AssertionError: {e}. Failed as anticipated.")
            
test_report_lifecycle_fail_forgot_move()

Hier ist die Ausgabe.

Operating test_report_lifecycle:
  Report created at 2023-11-01 10:00:00
  Transferring time to 2023-11-01 10:00:05
  Standing replace at 2023-11-01 10:00:05: 'Pending for five seconds.'
  Transferring time to 2023-11-01 10:01:00 and producing report
  Report generated at 2023-11-01 10:01:00
  Standing replace at 2023-11-01 10:01:00: 'Generated 0 seconds in the past.'
  Transferring time to 2023-11-01 10:01:30
  Standing replace at 2023-11-01 10:01:30: 'Generated 30 seconds in the past.'
  Complicated lifecycle check handed!

--- Operating lifecycle check (FAIL - forgot move_to) ---
  Report created at 2023-11-01 10:00:00
  Checking standing (time continues to be 2023-11-01 10:00:00)
  Standing replace at 2023-11-01 10:00:00: 'Pending for 0 seconds.'
  AssertionError: . Failed as anticipated.

Zusammenfassung

Freezegun ist ein fantastisches Device für jeden Python -Entwickler, der Code mit Daten und Zeiten testen muss. Es verwandelt potenziell schuppige, schwer zu schriftliche Exams in einfache, robuste und deterministische. Indem Sie mit Leichtigkeit einfrieren, ankreuzen und durch die Zeit reisen können – und es klar machen, wenn die Zeit ist nicht kontrolliert – Es entsperren die Fähigkeit, bisherige herausfordernde Szenarien effektiv und zuverlässig zu testen.

Um dies zu veranschaulichen, lieferte ich mehrere Beispiele für verschiedene Fälle, die Datums- und Zeittests umfassten, und zeigte, wie die Verwendung von Freezegun viele der Hindernisse beseitigt, auf die ein herkömmlicher Take a look at -Framework begegnen könnte.

Während wir die Kernfunktionalitäten behandelt haben, können Sie mehr mit Freezegun tun, und ich empfehle, sich zu überprüfen Github -Seite.

Kurz gesagt, Freezegun ist eine Bibliothek, die Sie kennen und verwenden sollten, wenn Ihr Code mit der Zeit handelt und Sie sie gründlich und zuverlässig testen müssen.

Stellen Sie sich ein Kundenservicecenter vor, das Ihre Sprache spricht, egal, um welche Sprache es sich handelt.

Alorica, ein Unternehmen in Irvine, Kalifornien, das weltweit Kundendienstzentren betreibt, hat eine künstliche Intelligenz Übersetzungstool, das es seinen Vertretern ermöglicht, mit Benutzern zu kommunizieren, die mindestens 200 verschiedene Sprachen und 75 Dialekte sprechen.

Interessanterweise kann ein Alorica-Vertreter, der beispielsweise Spanisch spricht, eine Beschwerde über einen störrischen Drucker oder ein anderes Downside eines Kantonesisch sprechenden Mitarbeiters in Hongkong einreichen. Alorica müsste keinen Vertreter einstellen, der Kantonesisch spricht.

Das ist die Macht der KI. Sie könnte als Bedrohung betrachtet werden: vielleicht, weil die Unternehmen nicht mehr viele Mitarbeiter brauchen und irgendwann einige Stellen abbauen werden. Wenn Chatbots den Großteil der Arbeitslast übernehmen können, werden die Unternehmen viele Mitarbeiter entlassen. Alorica stellt jedoch aggressiv ein.

Die Erfahrungen von Alorica, die auch in vielen anderen Unternehmen zu beobachten sind, deuten darauf hin, dass KI nicht der Jobkiller sein wird, den die meisten Menschen befürchten.

Stattdessen könnte die bahnbrechende Technologie eher wie frühere Durchbrüche funktionieren – Elektrizität, Dampfmaschine und Web: Sie vernichtet einige Arbeitsplätze, schafft aber viele neue. Das könnte die Produktivität der Arbeitnehmer steigern, was letztlich ihnen selbst, ihren Mitarbeitern und der Wirtschaft zugutekommt.

Laut Nick Bunker, einem führenden Ökonomen am Certainly Hiring Lab, wird die KI viele Arbeitsplätze beeinflussen, vielleicht sogar indirekt alle Arbeitsplätze. Er glaubt jedoch nicht, dass dies zu Massenarbeitslosigkeit führen wird. Er fügte hinzu:

„Wir haben in unserer Geschichte andere große technologische Ereignisse erlebt, und diese führten nicht zu einem großen Anstieg der Arbeitslosigkeit. Technologie zerstört, aber sie schafft auch. Es werden neue Arbeitsplätze entstehen.“

Die KI-Revolution

Künstliche Intelligenz befähigt Maschinen, verschiedene Aufgaben auszuführen, für die man bisher menschliche Intelligenz zu fordern glaubte. Die Technologie existiert schon seit Jahrzehnten. Sie entstand in den 1950er Jahren mit einem fortschrittlichen Computerprogramm zur Problemlösung, dem Logic Theorist, das an der heutigen Carnegie Mellon College entwickelt wurde.

Denken Sie in jüngster Zeit an Sprachassistenten wie Alexa und Siri. Oder an IBMs Schachcomputer Deep Blue, der es 1997 schaffte, den Weltmeister Garri Kasparow zu schlagen.

KI betrat 2022 die öffentliche Bühne, als OpenAI ChatGPT vorstellte, das generative KI-Device, das Computercode schreiben, Gespräche führen, Aufsätze verfassen, Musik komponieren und unbegrenzte Informationskanäle bereitstellen kann.

Der Einzug der generativen KI hat die Befürchtungen verstärkt, dass Chatbots Redakteure, freie Autoren, Telemarketing-Mitarbeiter, Programmierer, Anwaltsgehilfen, Kundendienstmitarbeiter und viele andere ersetzen werden. Sam Altman, CEO von OpenAI, kommentierte:

„KI wird viele bestehende Arbeitsplätze vernichten, und das wird die Funktionsweise vieler bestehender Arbeitsplätze verändern.“

Die weitverbreitete Annahme, dass KI-Chatbots Servicemitarbeiter ersetzen werden, so wie physische Roboter viele Fabrik- und Lagerarbeitsplätze ersetzt haben, muss sich bislang noch nicht in flächendeckender Type durchsetzen. Und vielleicht wird das auch nie passieren.

Der Wirtschaftsbeirat des Weißen Hauses erklärte im August 2024, er habe festgestellt „wenig Beweise dafür, dass KI sich negativ auf die Gesamtbeschäftigung auswirken wird.“ Berater sagten, die Geschichte zeige, dass Technologie Unternehmen normalerweise hochproduktiv mache, das Wirtschaftswachstum beschleunige und auf ungewöhnliche Weise neue Arten von Arbeitsplätzen schaffe.

Sie bezogen sich auf eine Studie aus dem Jahr 2024 unter der Leitung von David Autor, einem führenden Ökonomen des MIT. Darin hieß es, dass 60 % der Arbeitsplätze, die Amerikaner im Jahr 2018 innehatten, im Jahr 1940 noch gar nicht existierten, da sie durch andere, erst später aufkommende Technologien geschaffen wurden.

Andere Analysten sind der Meinung, dass es nicht genügend Belege für Entlassungen gibt, die auf arbeitssparende KI zurückzuführen sind. Das könnte in Zukunft passieren, aber bisher ist es noch nicht passiert.

Einige Berufe sind anfällig für KI

Die Befürchtung, dass KI eine large Bedrohung für einige Berufsgruppen darstellt, ist nicht unbegründet. So sorgte der indische Unternehmer Suumit Shah 2023 für Aufruhr, als er damit prahlte, er habe 90 % seiner Mitarbeiter im Kundensupport durch einen Chatbot namens Lina ersetzt.

Dieser Schritt bei Shahs Firma Dukaan, die Kunden beim Einrichten von E-Commerce-Websites unterstützt, reduzierte die Reaktionszeit auf Anfragen von Minuten auf nahezu „sofort“. Außerdem verkürzte sich die normalerweise zur Lösung von Problemen benötigte Zeit von über zwei Stunden auf etwa drei Minuten. Shah erklärte per E-Mail:

„Es geht um die Fähigkeit der KI, komplexe Anfragen präzise zu bearbeiten.“

Die Kosten für den Kundensupport sanken um 85 %. Dukaan weitete den Einsatz von KI-Lösungen auf Vertrieb und Analyse aus und diese Instruments werden immer leistungsfähiger.

Shah sagte:

„Es ist wie ein Improve von einem Corolla auf einen Tesla. Was früher Stunden dauerte, dauert heute nur noch Minuten. Und die Genauigkeit ist auf einem ganz neuen Niveau.“

Außerdem veröffentlichten Forscher des Deutschen Instituts für Wirtschaftsforschung, der Harvard Enterprise College und der Imperial School Enterprise College in London im Jahr 2023 eine Studie, in der sie feststellten, dass die Zahl der Stellenausschreibungen für Programmierer, Autoren und Künstler innerhalb von acht Monaten nach der Einführung von ChatGPT massiv zurückging.

KI kann menschliche Arbeitskräfte am Arbeitsplatz ergänzen

Eine gemeinsame Studie von Forschern der College of Pennsylvania, der Princeton College und der New York College aus dem Jahr 2023 ergab, dass Englisch- und Fremdsprachenlehrer sowie Telemarketing-Mitarbeiter am häufigsten von generativer KI und ChatGPT-ähnlichen Sprachmodellen betroffen sind. Allerdings bedeutet der Kontakt mit KI nicht, dass Sie Ihren Job an das Device verlieren. KI kann die mühsame Arbeit übernehmen und menschliche Arbeitskräfte für andere kreative Aufgaben freisetzen.

So führte der schwedische Möbelhändler IKEA 2021 einen Kundenservice-Chatbot ein, der einfache Anfragen beantworten sollte. Anstatt Mitarbeiter zu entlassen, behielt der Konzern 8.500 Kundendienstmitarbeiter, die sich anderen Aufgaben widmen sollten, etwa der Beratung von Benutzern bei der Inneneinrichtung und der Bearbeitung komplexer Kundenanrufe.

Chatbots können Mitarbeitern auch zu höherer Effizienz verhelfen, indem sie ihre Arbeit ergänzen, statt sie zu ersetzen. Eine Studie von Danielle Li und Lindsey Raymond vom MIT und Erik Brynjolfsson von der Stanford College verfolgte 5.200 Kundendienstmitarbeiter eines Fortune 500-Unternehmens, das generative KI-Assistenten einsetzte. Der Assistent machte wichtige Vorschläge für den Umgang mit Kunden. Er bot auch Hyperlinks zu relevanten internen Dokumenten.

Die Agenten, die den Chatbot nutzten, waren 14 % produktiver als die anderen, die ihn nicht nutzten. Sie bearbeiteten mehr Anrufe und erledigten ihre Arbeit schneller. Die größten Produktivitätszuwächse von 34 % verzeichneten die am wenigsten qualifizierten und unerfahrenen Mitarbeiter.

Bei Alorica nutzen Kundendienstmitarbeiter KI, um ihre Effizienz und Geschwindigkeit bei der Arbeit zu verbessern. Innerhalb von sechs Monaten half KI 850 Alorica-Mitarbeitern, ihre durchschnittliche Bearbeitungszeit von über acht Minuten auf sechs Minuten zu reduzieren.

Bemerkenswert ist, dass Alorica keine Arbeitsplätze abbaut, sondern weiterhin Leute einstellt, die mit der neuen Technologie vertraut sind.

Ein Aspekt, der Massive Language Fashions (LLMs) so leistungsstark macht, ist die Vielfalt der Aufgaben, auf die sie angewendet werden können. Dasselbe maschinelle Lernmodell, das einem Doktoranden beim Verfassen einer E-Mail helfen kann, könnte auch einem Kliniker bei der Diagnose von Krebs helfen.

Die breite Anwendbarkeit dieser Modelle macht es jedoch auch schwierig, sie systematisch zu bewerten. Es wäre unmöglich, einen Benchmark-Datensatz zu erstellen, um ein Modell anhand aller möglichen Fragen zu testen.

In einem neues Papierverfolgten die Forscher am MIT einen anderen Ansatz. Sie argumentieren, dass Menschen entscheiden, wann große Sprachmodelle eingesetzt werden. Zur Bewertung eines Modells müsse man verstehen, wie sich Menschen eine Meinung über dessen Fähigkeiten bilden, denn dies ist der Fall, wenn man weiß, wie Menschen sich ein Bild von dessen Fähigkeiten machen.

Beispielsweise muss der Doktorand entscheiden, ob das Modell beim Verfassen einer bestimmten E-Mail hilfreich sein könnte, und der Kliniker muss bestimmen, in welchen Fällen das Modell am besten zu Charge gezogen werden kann.

Auf dieser Idee aufbauend erstellten die Forscher einen Rahmen zur Bewertung eines LLM auf der Grundlage seiner Übereinstimmung mit den Überzeugungen eines Menschen hinsichtlich seiner Leistung bei einer bestimmten Aufgabe.

Sie führen eine menschliche Generalisierungsfunktion ein – ein Modell, das zeigt, wie Menschen ihre Ansichten über die Fähigkeiten eines LLMs aktualisieren, nachdem sie mit ihm interagiert haben. Anschließend bewerten sie, inwieweit LLMs mit dieser menschlichen Generalisierungsfunktion übereinstimmen.

Ihre Ergebnisse zeigen, dass ein Benutzer, wenn Modelle nicht auf die menschliche Generalisierungsfunktion abgestimmt sind, zu selbstsicher oder zu unsicher sein kann, wo er sie einsetzen soll, was zu unerwarteten Modellfehlern führen kann. Darüber hinaus neigen leistungsfähigere Modelle aufgrund dieser Fehlausrichtung dazu, in Situationen, in denen viel auf dem Spiel steht, schlechter abzuschneiden als kleinere Modelle.

„Diese Instruments sind spannend, weil sie universell einsetzbar sind. Aber weil sie universell einsetzbar sind, werden sie mit Menschen zusammenarbeiten. Deshalb müssen wir den Menschen in den Prozess einbeziehen“, sagt Ashesh Rambachan, Co-Autor der Studie, Assistenzprofessor für Wirtschaftswissenschaften und leitender Forscher am Laboratory for Info and Resolution Methods (LIDS).

Rambachan wird an der Arbeit von Hauptautor Keyon Vafa, einem Postdoc an der Harvard College, und Sendhil Mullainathan, einem MIT-Professor in den Abteilungen Elektrotechnik und Informatik sowie Wirtschaftswissenschaften und Mitglied von LIDS, unterstützt. Die Forschungsarbeit wird auf der Worldwide Convention on Machine Studying vorgestellt.

Menschliche Verallgemeinerung

Im Umgang mit anderen Menschen bilden wir uns ein Bild davon, was sie wissen und was nicht. Wenn Ihr Freund beispielsweise sehr pingelig ist, wenn es darum geht, die Grammatik anderer zu korrigieren, könnten Sie verallgemeinern und denken, dass er auch im Satzbau hervorragend ist, obwohl Sie ihm nie Fragen zum Satzbau gestellt haben.

„Sprachmodelle wirken oft so menschlich. Wir wollten zeigen, dass diese Kraft der menschlichen Verallgemeinerung auch in der Artwork und Weise vorhanden ist, wie Menschen ihre Ansichten über Sprachmodelle bilden“, sagt Rambachan.

Als Ausgangspunkt definierten die Forscher formal die menschliche Generalisierungsfunktion. Dabei werden Fragen gestellt, die Antworten einer Particular person oder eines LLM beobachtet und daraus Rückschlüsse gezogen, wie diese Particular person oder dieses Modell auf entsprechende Fragen reagieren würde.

Wenn jemand sieht, dass ein LLM Fragen zur Matrixinversion korrekt beantworten kann, könnte er auch annehmen, dass es Fragen zur einfachen Arithmetik mit Bravour meistert. Ein Modell, das nicht auf diese Funktion abgestimmt ist – additionally Fragen, von denen ein Mensch erwartet, dass es sie richtig beantwortet, nicht intestine beantwortet – könnte bei der Bereitstellung fehlschlagen.

Mit dieser formalen Definition in der Hand entwarfen die Forscher eine Umfrage, um zu messen, wie Menschen verallgemeinern, wenn sie mit LLMs und anderen Menschen interagieren.

Sie zeigten den Umfrageteilnehmern Fragen, die eine Particular person oder ein LLM richtig oder falsch beantwortet hatte, und fragten dann, ob sie glaubten, dass diese Particular person oder dieser LLM eine verwandte Frage richtig beantworten würde. Durch die Umfrage generierten sie einen Datensatz mit quick 19.000 Beispielen, wie Menschen die Leistung eines LLM bei 79 verschiedenen Aufgaben verallgemeinern.

Messen von Ausrichtungsfehlern

Sie stellten fest, dass die Teilnehmer recht intestine abschnitten, wenn man sie fragte, ob ein Mensch, der eine Frage richtig beantwortet hatte, auch eine verwandte Frage richtig beantworten würde. Sie waren jedoch viel schlechter darin, Verallgemeinerungen über die Leistung von LLMs abzugeben.

„Menschliche Generalisierung wird auf Sprachmodelle angewendet, aber das funktioniert nicht, weil diese Sprachmodelle keine Muster von Fachwissen zeigen, wie es bei Menschen der Fall wäre“, sagt Rambachan.

Die Teilnehmer neigten auch eher dazu, ihre Meinung über einen LLM zu ändern, wenn dieser Fragen falsch beantwortete, als wenn er Fragen richtig beantwortete. Sie neigten auch dazu, zu glauben, dass die Leistung eines LLM bei einfachen Fragen wenig Einfluss auf die Leistung bei komplexeren Fragen hätte.

In Situationen, in denen Menschen falschen Antworten mehr Gewicht beimaßen, schnitten einfachere Modelle besser ab als sehr große Modelle wie GPT-4.

„Sprachmodelle, die immer besser werden, können die Leute quick dazu verleiten zu glauben, dass sie bei verwandten Fragen gute Ergebnisse erzielen werden, obwohl das in Wirklichkeit nicht der Fall ist“, sagt er.

Eine mögliche Erklärung dafür, warum Menschen schlechter darin sind, LLMs zu verallgemeinern, könnte darin liegen, dass sie neuartig sind: Menschen haben weitaus weniger Erfahrung im Umgang mit LLMs als mit anderen Menschen.

„In Zukunft ist es möglich, dass wir allein durch die stärkere Interaktion mit Sprachmodellen besser werden“, sagt er.

Zu diesem Zweck möchten die Forscher weitere Studien darüber durchführen, wie sich die Ansichten der Menschen über LLMs im Laufe der Zeit entwickeln, wenn sie mit einem Modell interagieren. Sie möchten auch untersuchen, wie menschliche Generalisierung in die Entwicklung von LLMs einbezogen werden könnte.

„Wenn wir diese Algorithmen überhaupt erst trainieren oder versuchen, sie mit menschlichem Suggestions zu aktualisieren, müssen wir bei unserer Betrachtung der Leistungsmessung die menschliche Generalisierungsfunktion berücksichtigen“, sagt er.

In der Zwischenzeit hoffen die Forscher, dass ihr Datensatz als Benchmark verwendet werden kann, um die Leistung von LLMs im Zusammenhang mit der menschlichen Generalisierungsfunktion zu vergleichen. Dies könnte dazu beitragen, die Leistung von Modellen zu verbessern, die in realen Situationen eingesetzt werden.

„Für mich hat der Beitrag des Papiers zweierlei. Der erste ist praktischer Natur: Das Papier deckt ein kritisches Downside bei der Bereitstellung von LLMs für den allgemeinen Verbrauchergebrauch auf. Wenn die Leute nicht das richtige Verständnis dafür haben, wann LLMs genau sind und wann sie versagen, werden sie eher Fehler bemerken und sich vielleicht von der weiteren Verwendung abhalten lassen. Dies verdeutlicht das Downside, die Modelle an das Verständnis der Leute von Generalisierung anzupassen“, sagt Alex Imas, Professor für Verhaltenswissenschaften und Ökonomie an der Sales space College of Enterprise der College of Chicago, der nicht an dieser Arbeit beteiligt conflict. „Der zweite Beitrag ist grundlegender: Das Fehlen einer Generalisierung auf erwartete Probleme und Domänen hilft dabei, ein besseres Bild davon zu bekommen, was die Modelle tun, wenn sie ein Downside ‚richtig‘ lösen. Es bietet einen Take a look at dafür, ob LLMs das Downside ‚verstehen‘, das sie lösen.“

Diese Forschung wurde zum Teil von der Harvard Information Science Initiative und dem Heart for Utilized AI der College of Chicago Sales space College of Enterprise finanziert.

OpenAI scheint jeden Tag Schlagzeilen zu machen, und dieses Mal sind es doppelte Sicherheitsbedenken. OpenAI ist für seine bahnbrechenden Fortschritte in der künstlichen Intelligenz bekannt und steht nun ins Rampenlicht, und zwar nicht nur wegen zwei gravierende Sicherheitsverstöße.

Diese Vorfälle haben Fragen zum Umgang des Unternehmens mit Daten und zu seinen Cybersicherheitsprotokollen aufgeworfen und das Vertrauen sowohl der Benutzer als auch der Branchenexperten erschüttert.

ChatGPT für Mac ist voller Sicherheitslücken

Der Mac-App für ChatGPT ist ein beliebtes Werkzeug für Benutzer, die das leistungsstarke Sprachmodell von OpenAI nutzen möchten. GPT-4odirekt von ihren Desktops aus. Diese Woche wurde jedoch eine Sicherheitslücke aufgedeckt.

Pedro José Pereira Vieitoein Swift-Entwickler, entdeckte, dass die App Benutzergespräche im Klartext lokal auf dem Gerät speicherte. Das bedeutet, dass alle während dieser Gespräche ausgetauschten vertraulichen Informationen nicht geschützt waren und somit für andere Anwendungen oder potenzielle Malware zugänglich waren.

macOS blockiert seit macOS Mojave 10.14 (vor 6 Jahren!) den Zugriff auf alle privaten Benutzerdaten. Jede App, die auf non-public Benutzerdaten zugreift (Kalender, Kontakte, E-Mail, Fotos, Sandboxen von Drittanbieter-Apps usw.), erfordert jetzt expliziten Benutzerzugriff.

— Pedro José Pereira Vieito (@pvieito) 2. Juli 2024

Vieitos Erkenntnisse wurden schnell von Tech-Nachrichtenagenturen aufgegriffen Der Randwas die Besorgnis unter den Benutzern verstärkte und OpenAI dazu veranlasste, rasch zu handeln. Das Unternehmen veröffentlichte ein Replace, das Verschlüsselung für lokal gespeicherte Chats eingeführtum das unmittelbare Sicherheitsproblem anzugehen.

Das Fehlen von Sandboxing, einer Sicherheitsmethode, die Anwendungen isoliert, um zu verhindern, dass Schwachstellen andere Teile des Programs beeinträchtigen, erschwerte das Downside noch weiter. Da die ChatGPT-App nicht auf dem Apple App RetailerEs muss nicht den Sandboxing-Anforderungen von Apple entsprechen.

Die Tatsache, dass es überhaupt zu einem derart grundlegenden Sicherheitsversehen kam, wirft Fragen zu den internen Sicherheitspraktiken von OpenAI und der Gründlichkeit ihres App-Entwicklungsprozesses auf.

Durch diese Lücke konnte die App Daten unsicher speichern und Benutzer potenziellen Risiken aussetzen.

Die schnelle Lösung durch OpenAI hat die unmittelbare Bedrohung eingedämmt, aber auch die Notwendigkeit strengerer Sicherheitsmaßnahmen bei der Entwicklung und Bereitstellung von KI-Anwendungen hervorgehoben.

Das Spielbuch eines Hackers

Das zweite Sicherheitsproblem von OpenAI ist wurzelt in einem Vorfall vom letzten Frühjahraber seine Auswirkungen sind noch heute spürbar.

Anfang letzten Jahres Einem Hacker gelang es, in die internen Nachrichtensysteme von OpenAI einzudringenund erhalten Zugang zu vertraulichen Informationen über die Geschäftstätigkeit und KI-Technologien des Unternehmens. Hacker entwendete Particulars aus Diskussionen in einem On-line-Discussion board, in dem Mitarbeiter über die neuesten Technologien von OpenAI sprachenso zwei mit dem Vorfall vertraute Personen, hatte jedoch keinen Zugriff auf die Systeme, in denen das Unternehmen seine KI beherbergt und baut.

Führungskräfte von OpenAI berichteten den Mitarbeitern von dem Vorfall während einer All-Fingers-Assembly im Büro des Unternehmens in San Francisco im April 2023. Es wurde jedoch entschieden, den Verstoß nicht öffentlich bekannt zu geben, da keine Kunden- oder Partnerinformationen gestohlen wurden und die Führungskräfte ihn nicht als Bedrohung für die nationale Sicherheit betrachteten. Sie glaubten, dass die Hacker battle eine Privatperson ohne Verbindungen zu einer ausländischen Regierungso dass sie informierte weder das FBI noch die Strafverfolgungsbehörden.

Diese Entscheidung führte zu internen Bedenken hinsichtlich der Sicherheitslage von OpenAI. Einige Mitarbeiter befürchteten, dass Ausländische Gegner wie China könnten möglicherweise ähnliche Schwachstellen ausnutzen um KI-Technologie zu stehlen, die letztendlich eine Bedrohung für die nationale Sicherheit der USA darstellen könnte.

Leopold Aschenbrenner, ein Technischer Programmmanager von OpenAIargumentierte, dass Das Unternehmen hat nicht genügend Maßnahmen ergriffen, um solche Bedrohungen zu verhindernEr sandte ein Memo an den Vorstand, in dem er seine Bedenken darlegte, wurde jedoch später entlassen. Seiner Aussage nach battle der Schritt aufgrund seiner Enthüllungen politisch motiviert.

Geflüsterte Sorgen

Der interner Verstoß und anschließende Behandlung des Vorfalls haben tiefere Risse innerhalb von OpenAI in Bezug auf Sicherheitspraktiken und Transparenz aufgedeckt. Aschenbrenners Entlassung, die seiner Aussage nach eine Folge seiner Whistleblowing-Aktivitäten battle, hat eine Debatte über das Engagement des Unternehmens für Sicherheit und den Umgang mit internen Meinungsverschiedenheiten ausgelöst. Während OpenAI behauptet, dass seine Entlassung nichts mit seiner Whistleblowing-Aktivität zu tun hatte, hat die State of affairs Spannungen innerhalb des Unternehmens deutlich gemacht.

Der Datendiebstahl und seine Folgen haben auch die potenziellen geopolitischen Risiken unterstrichen, die mit hochentwickelten KI-Technologien einhergehen. Die Befürchtung, dass KI-Geheimnisse von ausländischen Gegnern wie China gestohlen werden könnten, ist nicht unbegründet. Ähnliche Bedenken wurden auch in der Technologiebranche geäußert, insbesondere von Microsoft-Präsident Brad Smith, der aussagte, chinesische Hacker würden technische Systeme ausnutzen, um staatliche Netzwerke anzugreifen.

Trotz dieser Bedenken verhindern Bundes- und Landesgesetze, dass Unternehmen wie OpenAI aufgrund der Nationalität diskriminieren. Experten argumentieren, dass der Ausschluss ausländischer Talente die KI-Entwicklung in den USA behindern könnte. Matt Knight, Sicherheitschef von OpenAI, betonte die Notwendigkeit, diese Risiken auszugleichen und gleichzeitig die besten Talente weltweit zu nutzen, um KI-Technologien voranzutreiben.

Was ist das Machtspiel von OpenAI?

Als Reaktion auf diese Vorfälle OpenAI hat Schritte unternommen, um seine Sicherheitsmaßnahmen zu stärkenDas Unternehmen hat eine Sicherheitsausschuss um die mit zukünftigen Technologien verbundenen Risiken zu bewerten und zu mindern. Zu diesem Ausschuss gehören namhafte Persönlichkeiten wie Paul Nakasoneein ehemaliger Normal der Armee, der die Nationwide Safety Company und das Cyber ​​Command leitete und in den Vorstand von OpenAI berufen wurde.

OpenAIs Engagement für Sicherheit wird auch durch die laufenden Investitionen in die Absicherung seiner Technologien unter Beweis gestellt. Knight betonte, dass diese Bemühungen bereits Jahre vor der Einführung von ChatGPT begannen und sich weiter entwickeln, da das Unternehmen versucht, neu entstehende Risiken zu verstehen und anzugehen. Trotz dieser proaktiven Maßnahmen haben die jüngsten Vorfälle gezeigt, dass der Weg zu robuster Sicherheit noch nicht zu Ende ist und ständige Wachsamkeit erfordert.

---

Bildnachweis für vorgestelltes Bild: Kim Menikh/Unsplash