Integracja sztucznej inteligencji (AI) w ramach AWS RDS MySQL do cotygodniowego zarządzania terabajtami danych dotyczących lotów obejmuje wykorzystanie rozległego ekosystemu usług AWS w zakresie sztucznej inteligencji i danych. Integracja ta umożliwia zwiększenie możliwości przetwarzania, analizy i przewidywania danych. Proces ten zazwyczaj obejmuje odczytywanie ogromnych ilości danych z jeziora danych, przechowywanie i zarządzanie tymi danymi w AWS RDS MySQL oraz stosowanie sztucznej inteligencji w celu uzyskania wglądu i prognoz. Oto kompleksowe podejście z przykładem w czasie rzeczywistym.

Pozyskiwanie danych z jeziora danych do AWS RDS MySQL

Pozyskiwanie danych z jeziora danych, zazwyczaj przechowywanych w Amazon S3do AWS RDS MySQL obejmuje kilka kroków, w tym konfigurację zadania AWS Glue dla procesów ETL. Ten przykład przedstawia proces tworzenia AWS Glue ETL zadanie przeniesienia terabajtów danych lotu z jeziora danych S3 do instancji AWS RDS MySQL.

Wymagania wstępne

• Konto AWS: Proszę upewnić się, że mają Państwo aktywne konto AWS.
• Dane w Amazon S3: Państwa dane lotu powinny być przechowywane w zasobniku S3 w zorganizowany sposób, najlepiej w formatach takich jak CSV, JSON lub Parquet.
• Wystąpienie AWS RDS MySQL: Proszę skonfigurować instancję AWS RDS z uruchomionym serwerem MySQL. Proszę zanotować nazwę bazy danych, nazwę użytkownika i hasło.

Proszę zdefiniować katalog danych

Przed utworzeniem zadania ETL należy zdefiniować źródło (S3) i cel (RDS MySQL) w AWS Glue Data Catalog.

• Proszę przejść do konsoli AWS Glue.
• W sekcji Databases proszę utworzyć nową bazę danych dla S3 data lake i RDS MySQL, jeśli nie została jeszcze zdefiniowana.
• Proszę użyć opcji Tabele w bazie danych, aby dodać nową tabelę dla danych lotu S3. Proszę określić ścieżkę S3 i wybrać klasyfikator pasujący do formatu danych (np. CSV, JSON).

Tworzenie zadania ETL w AWS Glue

1. W konsoli AWS Glue proszę przejść do sekcji Jobs i kliknąć Add Job.
2. Proszę wypełnić właściwości zadania:
   • Imię i nazwisko: Proszę wprowadzić nazwę zadania.
   • Rola IAM: Proszę wybrać lub utworzyć rolę IAM, która ma uprawnienia dostępu do danych S3 i instancji RDS MySQL.
   • Typ: Proszę wybrać “Spark”.
   • Wersja kleju: Proszę wybrać wersję Glue, która obsługuje Państwa format danych.
   • To zadanie zostanie uruchomione: Proszę wybrać “Proponowany skrypt wygenerowany przez AWS Glue”.
   • Skrypt automatycznie wygeneruje skrypt dla Państwa.
   • Źródło danych: Proszę wybrać tabelę S3 z katalogu danych.
   • Cel danych: Proszę wybrać tabelę RDS MySQL z katalogu danych. Proszę wprowadzić szczegóły połączenia RDS.
   • Mapowanie: AWS Glue zasugeruje mapowanie między danymi źródłowymi i docelowymi. Proszę przejrzeć i dostosować mapowania w razie potrzeby, aby dopasować je do schematu tabeli RDS MySQL.

Dostosowanie skryptu ETL (opcjonalnie)

AWS Glue generuje skrypt PySpark na podstawie dokonanych przez Państwa wyborów. Skrypt ten można dostosować do przekształceń lub obsługi złożonych scenariuszy.

import sys

from awsglue.transforms import *

from awsglue.utils import getResolvedOptions

from pyspark.context import SparkContext

from awsglue.context import GlueContext

from awsglue.job import Job

 

## @params: [JOB_NAME]

args = getResolvedOptions(sys.argv, ['JOB_NAME'])

 

sc = SparkContext()

glueContext = GlueContext(sc)

spark = glueContext.spark_session

job = Job(glueContext)

job.init(args['JOB_NAME'], args)

 

## Data source and transformation logic here

 

## Write data back to RDS MySQL

datasink4 = glueContext.write_dynamic_frame.from_jdbc_conf(frame = ApplyMapping_node3, catalog_connection = "YourRDSDatabaseConnection", connection_options = {"dbtable": "your_target_table", "database": "your_database"}, transformation_ctx = "datasink4")

 

job.commit()

Zaplanowanie i uruchomienie zadania ETL

Po skonfigurowaniu zadania ETL można skonfigurować jego uruchamianie zgodnie z harmonogramem (np. co tydzień dla nowych danych lotu) lub uruchomić je ręcznie z poziomu konsoli AWS Glue. Proszę monitorować przebieg zadania w zakładce Historia w szczegółach zadania.

Konfiguracja AWS RDS MySQL dla integracji AI

Konfiguracja AWS RDS MySQL do integracji AI, szczególnie w przypadku scenariuszy obejmujących dane na dużą skalę, takie jak terabajty informacji o lotach, wymaga starannego planowania w zakresie projektowania schematu bazy danych, optymalizacji wydajności i efektywnego pozyskiwania danych. Oto jak można do tego podejść, w tym przykładowy kod do tworzenia tabel i przygotowywania danych do analizy AI przy użyciu usług AWS, takich jak RDS MySQL i integracji z usługami uczenia maszynowego, takimi jak Amazon SageMaker.

Projektowanie schematu bazy danych AWS RDS MySQL

Projektując schemat, proszę rozważyć, w jaki sposób model AI będzie wykorzystywał dane. W przypadku danych lotu mogą być potrzebne tabele dla lotów, samolotów, dzienników konserwacji, warunków pogodowych i informacji o pasażerach.

CREATE TABLE flights (

    flight_id INT AUTO_INCREMENT PRIMARY KEY,

    flight_number VARCHAR(255) NOT NULL,

    departure_airport_code VARCHAR(5),

    arrival_airport_code VARCHAR(5),

    scheduled_departure_time DATETIME,

    scheduled_arrival_time DATETIME,

    status VARCHAR(50),

    -- Additional flight details here

);

 

CREATE TABLE aircraft (

    aircraft_id INT AUTO_INCREMENT PRIMARY KEY,

    model VARCHAR(255) NOT NULL,

    manufacturer VARCHAR(255),

    capacity INT

    -- Additional aircraft details here

);

Tabela dzienników obsługi technicznej

W tabeli tej zapisywane są czynności obsługi technicznej dla każdego statku powietrznego. Zawiera ona informacje na temat rodzaju wykonanej obsługi technicznej, daty i wszelkich uwag związanych z czynnościami obsługi technicznej.

CREATE TABLE maintenance_logs (

    log_id INT AUTO_INCREMENT PRIMARY KEY,

    aircraft_id INT NOT NULL,

    maintenance_date DATE NOT NULL,

    maintenance_type VARCHAR(255),

    notes TEXT,

    -- Ensure there's a foreign key relationship with the aircraft table

    CONSTRAINT fk_aircraft

        FOREIGN KEY (aircraft_id) 

        REFERENCES aircraft (aircraft_id)

        ON DELETE CASCADE

);

Tabela pogody

Tabela pogody przechowuje informacje o warunkach pogodowych na różnych lotniskach w określonym czasie. Dane te mają kluczowe znaczenie dla analizy opóźnień i odwołań lotów oraz optymalizacji tras lotów.

CREATE TABLE weather (

    weather_id INT AUTO_INCREMENT PRIMARY KEY,

    airport_code VARCHAR(5) NOT NULL,

    recorded_time DATETIME NOT NULL,

    temperature DECIMAL(5,2),

    visibility INT,

    wind_speed DECIMAL(5,2),

    precipitation DECIMAL(5,2),

    condition VARCHAR(255),

    -- Additional weather details as needed

    INDEX idx_airport_time (airport_code, recorded_time)

);

Tabela pasażerów

Ta tabela przechowuje informacje o pasażerach każdego lotu. Obejmuje ona dane osobowe i informacje związane z lotem, które mogą być wykorzystane do poprawy komfortu pasażerów poprzez spersonalizowane usługi lub programy lojalnościowe.

CREATE TABLE passengers (

    passenger_id INT AUTO_INCREMENT PRIMARY KEY,

    flight_id INT NOT NULL,

    first_name VARCHAR(255) NOT NULL,

    last_name VARCHAR(255) NOT NULL,

    seat_number VARCHAR(10),

    loyalty_program_id VARCHAR(255),

    special_requests TEXT,

    -- Ensure there's a foreign key relationship with the flights table

    CONSTRAINT fk_flight

        FOREIGN KEY (flight_id) 

        REFERENCES flights (flight_id)

        ON DELETE CASCADE

);

Optymalizacja wydajności dla dużych zbiorów danych

W przypadku integracji sztucznej inteligencji, zwłaszcza w przypadku analizy danych wrażliwych na czas lub prognoz w czasie rzeczywistym, należy upewnić się, że instancja MySQL jest zoptymalizowana. Obejmuje to indeksowanie krytycznych kolumn i rozważenie partycjonowania dużych tabel.

-- Indexing example for quicker lookups

CREATE INDEX idx_flight_number ON flights(flight_number);

CREATE INDEX idx_departure_arrival ON flights(departure_airport_code, arrival_airport_code);

 

-- Consider partitioning large tables by a suitable key, such as date

ALTER TABLE flights PARTITION BY RANGE ( YEAR(scheduled_departure_time) ) (

    PARTITION p2020 VALUES LESS THAN (2021),

    PARTITION p2021 VALUES LESS THAN (2022),

    -- Add more partitions as needed

);

Wdrażanie tabel

Po zdefiniowaniu SQL dla tych tabel, proszę wykonać polecenia w instancji AWS RDS MySQL. Proszę upewnić się, że aircraft_id w maintenance_logs oraz flight_id w pasażerach poprawnie odwołują się do swoich tabel nadrzędnych, aby zachować integralność danych. Tabela pogody, zaprojektowana z INDEX na airport_code i recorded_time, pomaga zoptymalizować zapytania związane z określonymi lotniskami i godzinami – ważne dla zapytań operacyjnych i analitycznych związanych z planowaniem i analizą lotów.

Przygotowanie danych do analizy AI

Aby wykorzystać dane w modelach sztucznej inteligencji w SageMaker, może być konieczne wstępne przetworzenie i zagregowanie danych do formatu, który może być łatwo wykorzystany przez model.

• AWS Glue for ETL: Proszę użyć AWS Glue, aby przekształcić nieprzetworzone dane lotu w format przyjazny dla uczenia maszynowego. Może to obejmować agregację danych, obsługę brakujących wartości, kodowanie zmiennych kategorialnych itp.

# Pseudocode for an AWS Glue job to prepare data for SageMaker

 

import awsglue.transforms as Transforms

from awsglue.context import GlueContext

 

glueContext = GlueContext(SparkContext.getOrCreate())

 

datasource = glueContext.create_dynamic_frame.from_catalog(

    database="your_database",

    table_name="flights",

    transformation_ctx="datasource"

)

 

# Apply various transformations such as filtering, mapping, joining with other datasets

transformed = datasource.apply_mapping(...).filter(...)

 

# Write the transformed data to an S3 bucket in a format SageMaker can use (e.g., CSV)

glueContext.write_dynamic_frame.from_options(

    frame=transformed,

    connection_type="s3",

    connection_options={"path": "s3://your-bucket/for-sagemaker/"},

    format="csv"

)

Integracja z Amazon SageMaker

Po przygotowaniu i zapisaniu danych w dostępnym formacie można utworzyć model uczenia maszynowego w programie SageMaker w celu analizy danych lotu.

• Tworzenie notatnika SageMaker: Proszę rozpocząć od utworzenia notatnika Jupyter w programie SageMaker i załadowania zestawu danych z zasobnika S3.

import sagemaker

import boto3

 

s3 = boto3.client('s3')

bucket="your-bucket"

data_key = 'for-sagemaker/your-data.csv'

data_location = f's3://{bucket}/{data_key}'

 

# Load data into a pandas DataFrame, for example

import pandas as pd

 

df = pd.read_csv(data_location)

• Trening modelu: Proszę użyć wbudowanych algorytmów SageMaker lub przynieść własny model do trenowania na zestawie danych. Proszę postępować zgodnie z dokumentacją konkretnego algorytmu lub frameworka, którego Państwo używają, aby uzyskać szczegółowe informacje na temat trenowania modelu.

Widok i procedury składowane

Tworzenie widoków i procedur składowanych może znacznie poprawić dostępność i zarządzanie danymi w bazie danych AWS RDS MySQL, szczególnie w przypadku złożonych zapytań i operacji związanych z lotami, samolotami, dziennikami konserwacji, pogodą i pasażerami. Poniżej znajduje się przykład, w jaki sposób można utworzyć przydatne widoki i procedury składowane dla tych jednostek.

Tworzenie widoków

Widoki mogą uprościć dostęp do danych dla typowych zapytań, zapewniając wirtualną tabelę opartą na zestawie wyników instrukcji SQL.

Widok szczegółów lotu z warunkami pogodowymi

CREATE VIEW flight_details_with_weather AS

SELECT 

    f.flight_id, 

    f.flight_number, 

    f.departure_airport_code, 

    f.arrival_airport_code, 

    w.condition AS departure_weather_condition,

    w2.condition AS arrival_weather_condition

FROM 

    flights f

JOIN 

    weather w ON (f.departure_airport_code = w.airport_code AND DATE(f.scheduled_departure_time) = DATE(w.recorded_time))

JOIN 

    weather w2 ON (f.arrival_airport_code = w2.airport_code AND DATE(f.scheduled_arrival_time) = DATE(w2.recorded_time));

Ten widok łączy loty z warunkami pogodowymi na lotniskach odlotu i przylotu, zapewniając szybki przegląd do planowania lotu lub analizy.

Widok podsumowania obsługi technicznej statku powietrznego

CREATE VIEW aircraft_maintenance_summary AS

SELECT 

    a.aircraft_id, 

    a.model,

    COUNT(m.log_id) AS maintenance_count,

    MAX(m.maintenance_date) AS last_maintenance_date

FROM 

    aircraft a

LEFT JOIN 

    maintenance_logs m ON a.aircraft_id = m.aircraft_id

GROUP BY 

    a.aircraft_id;

Ten widok zawiera podsumowanie działań konserwacyjnych dla każdego statku powietrznego, w tym całkowitą liczbę działań konserwacyjnych i datę ostatniej konserwacji.

Tworzenie procedur przechowywanych

Procedury składowane umożliwiają hermetyzację zapytań i poleceń SQL w celu wykonywania złożonych operacji. Mogą one być szczególnie przydatne do wstawiania lub aktualizowania danych w wielu tabelach w sposób transakcyjny.

Procedura składowana dodająca nowy lot i jego pasażerów

DELIMITER $$

CREATE PROCEDURE AddFlightAndPassengers(

    IN _flight_number VARCHAR(255),

    IN _departure_code VARCHAR(5),

    IN _arrival_code VARCHAR(5),

    IN _departure_time DATETIME,

    IN _arrival_time DATETIME,

    IN _passengers JSON -- Assume passengers data is passed as a JSON array

)

BEGIN

    DECLARE _flight_id INT;

    

    -- Insert the new flight

    INSERT INTO flights(flight_number, departure_airport_code, arrival_airport_code, scheduled_departure_time, scheduled_arrival_time)

    VALUES (_flight_number, _departure_code, _arrival_code, _departure_time, _arrival_time);

    

    SET _flight_id = LAST_INSERT_ID();

    

    -- Loop through the JSON array of passengers and insert each into the passengers table

    -- Note: This is pseudocode. MySQL 5.7+ supports JSON manipulation functions.

    -- You might need to parse and iterate over the JSON array in your application code or use MySQL 8.0 functions like JSON_TABLE.

    

    CALL AddPassengerForFlight(_flight_id, _passenger_name, _seat_number, _loyalty_program_id, _special_requests);

    

END $$

DELIMITER ;

Pomocnik procedury składowanej dodającej pasażera do lotu

Jest to uproszczony przykład, który można wywołać z aplikacji AddFlightAndPassengers procedury.

DELIMITER $$

CREATE PROCEDURE AddPassengerForFlight(

    IN _flight_id INT,

    IN _name VARCHAR(255),

    IN _seat_number VARCHAR(10),

    IN _loyalty_program_id VARCHAR(255),

    IN _special_requests TEXT

)

BEGIN

    INSERT INTO passengers(flight_id, name, seat_number, loyalty_program_id, special_requests)

    VALUES (_flight_id, _name, _seat_number, _loyalty_program_id, _special_requests);

END $$

DELIMITER ;

Wykorzystanie sztucznej inteligencji do analizy danych i prognozowania

Wykorzystanie sztucznej inteligencji do analizy danych i prognozowania obejmuje kilka etapów, od przygotowania danych po szkolenie modeli i wnioskowanie. Ten przykład ilustruje, jak używać Amazon SageMaker do uczenia maszynowego z danymi przechowywanymi w AWS RDS MySQL, koncentrując się na przewidywaniu opóźnień lotów na podstawie historycznych danych lotu, warunków pogodowych, dzienników konserwacji i informacji o pasażerach.

Przygotowanie danych

Przed uczeniem modelu należy przygotować zestaw danych. Często wiąże się to z zapytaniem do bazy danych RDS MySQL w celu skonsolidowania niezbędnych danych do formatu odpowiedniego dla uczenia maszynowego.

Zakładając, że mają Państwo tabele dla lotów, samolotów, dzienników konserwacji, pogody i pasażerów w AWS RDS MySQL, można utworzyć widok, który agreguje odpowiednie informacje:

CREATE VIEW flight_data_analysis AS

SELECT

    f.flight_number,

    f.scheduled_departure_time,

    f.scheduled_arrival_time,

    w.temperature,

    w.wind_speed,

    w.condition AS weather_condition,

    m.maintenance_type,

    COUNT(p.passenger_id) AS passenger_count,

    f.status AS flight_status -- Assume 'Delayed' or 'On Time'

FROM

    flights f

JOIN weather w ON (f.departure_airport_code = w.airport_code AND DATE(f.scheduled_departure_time) = DATE(w.recorded_time))

LEFT JOIN maintenance_logs m ON f.aircraft_id = m.aircraft_id

LEFT JOIN passengers p ON f.flight_id = p.flight_id

GROUP BY

    f.flight_id;

Widok ten łączy dane lotu z warunkami pogodowymi, typem konserwacji i liczbą pasażerów dla każdego lotu, co można wykorzystać do przewidywania opóźnień lotów.

Eksport danych do S3

Proszę użyć zadania AWS Glue ETL, aby wyodrębnić dane z tego widoku i zapisać je w zasobniku Amazon S3 w formacie, którego może używać Amazon SageMaker, np. CSV:

# Pseudocode for AWS Glue ETL job

glueContext.create_dynamic_frame.from_catalog(

    database = "your-rds-database",

    table_name = "flight_data_analysis",

    transformation_ctx = "datasource"

).toDF().write.format("csv").save("s3://your-bucket/flight-data/")

Trenowanie modelu za pomocą Amazon SageMaker

• Proszę utworzyć instancję notebooka SageMaker: Proszę otworzyć konsolę SageMaker, utworzyć nową instancję notatnika i otworzyć notatnik Jupyter.
• Proszę załadować dane: Proszę załadować dane z zasobnika S3 do notatnika:

import sagemaker

import boto3

import pandas as pd

 

# Define S3 bucket and path

bucket="your-bucket"

data_key = 'flight-data/your-data.csv'

data_location = f's3://{bucket}/{data_key}'

 

# Load the dataset

df = pd.read_csv(data_location)

• Wstępne przetwarzanie danych: W razie potrzeby należy wstępnie przetworzyć dane, w tym obsłużyć brakujące wartości, zakodować zmienne kategorialne i podzielić dane na zestawy treningowe i testowe.
• Proszę wybrać model i przeprowadzić szkolenie: Dla uproszczenia użyjemy algorytmu XGBoost dostarczonego przez SageMaker:

from sagemaker import get_execution_role

from sagemaker.amazon.amazon_estimator import get_image_uri

 

# Get the XGBoost image

xgboost_container = get_image_uri(boto3.Session().region_name, 'xgboost')

 

# Initialize the SageMaker estimator

xgboost = sagemaker.estimator.Estimator(

    image_uri=xgboost_container,

    role=get_execution_role(),

    train_instance_count=1,

    train_instance_type="ml.m4.xlarge",

    output_path=f's3://{bucket}/output/'

)

 

# Set hyperparameters (simplified for example)

xgboost.set_hyperparameters(

    eta=0.2,

    max_depth=5,

    objective="binary:logistic",

    num_round=100

)

 

# Train the model

xgboost.fit({'train': data_location})

• Proszę wdrożyć i utworzyć prognozy: Wdrożenie modelu do punktu końcowego i wykorzystanie go do tworzenia prognoz.

predictor = xgboost.deploy(initial_instance_count=1, instance_type="ml.m4.xlarge")

 

# Example prediction (pseudo-code, you'll need to format your input data correctly)

result = predictor.predict(test_data)

Czyszczenie

Proszę pamiętać o usunięciu punktu końcowego SageMaker po użyciu, aby uniknąć niepotrzebnych opłat.

Automatyzacja analizy AI z powrotem do operacji biznesowych

Automatyzacja integracji spostrzeżeń AI z powrotem do operacji biznesowych może znacznie usprawnić podejmowanie decyzji i wydajność operacyjną. Obejmuje to nie tylko generowanie spostrzeżeń za pomocą modeli uczenia maszynowego, ale także płynne włączanie tych spostrzeżeń do biznesowych przepływów pracy. W tym kontekście przeanalizujemy wykorzystanie usług AWS do zautomatyzowania wprowadzania spostrzeżeń AI generowanych z Amazon SageMaker do operacji biznesowych, koncentrując się na scenariuszu, w którym spostrzeżenia są wykorzystywane do optymalizacji operacji lotniczych.

Przegląd scenariusza

Rozważmy linię lotniczą wykorzystującą model uczenia maszynowego hostowany w Amazon SageMaker do przewidywania opóźnień lotów w oparciu o różne czynniki, w tym warunki pogodowe, historię konserwacji samolotów i harmonogramy lotów. Celem jest zautomatyzowanie procesu przekazywania tych prognoz z powrotem do operacyjnego przepływu pracy w celu optymalizacji harmonogramów lotów i planów konserwacji.

Generowanie prognoz za pomocą Amazon Sagemaker

Zakładając, że mają Państwo wdrożony SageMaker który zapewnia prognozy opóźnień, można użyć AWS Lambda do wywołania tego punktu końcowego z wymaganymi danymi i otrzymania prognoz.

Tworzenie funkcji AWS Lambda

• Język: Python 3.8
• Uprawnienia: Proszę przypisać rolę z uprawnieniami do wywoływania punktów końcowych SageMaker oraz do odczytu/zapisu do dowolnej wymaganej usługi AWS (np. RDS, S3, SQS).

Wywołanie punktu końcowego SageMaker z Lambda

import boto3

import json

 

def lambda_handler(event, context):

    # Initialize SageMaker runtime client

    sage_client = boto3.client('sagemaker-runtime')

 

    # Specify your SageMaker endpoint name

    endpoint_name = "your-sagemaker-endpoint-name"

    

    # Assuming 'event' contains the input data for prediction

    data = json.loads(json.dumps(event))

    payload = json.dumps(data)

 

    response = sage_client.invoke_endpoint(EndpointName=endpoint_name,

                                            ContentType="application/json",

                                            Body=payload)

                                           

    # Parse the response

    result = json.loads(response['Body'].read().decode())

    

    # Process the result to integrate with business operations

    process_prediction(result)

    

    return {

        'statusCode': 200,

        'body': json.dumps('Prediction processed successfully.')

    }

 

def process_prediction(prediction):

    # Implement how predictions are used in business operations.

    # For example, adjusting flight schedules or maintenance plans.

    # This is a placeholder function.

    pass

Automatyzacja przewidywań

Aby zautomatyzować przewidywania, można uruchomić funkcję Lambda na podstawie różnych zdarzeń. Można na przykład użyć Amazon CloudWatch Events (lub Amazon EventBridge), aby uruchomić funkcję zgodnie z harmonogramem (np. codziennie, aby dostosować harmonogramy lotów na następny dzień) lub uruchomić funkcję w odpowiedzi na określone zdarzenia (np. aktualizacje prognozy pogody).

Integracja prognoz z operacjami biznesowymi

The process_prediction w ramach Lambda jest symbolem zastępczym dla logiki, która integruje prognozy z powrotem do Państwa operacyjnych przepływów pracy. Oto uproszczony przykład tego, jak można dostosować harmonogramy lotów w oparciu o prognozy opóźnień:

def process_prediction(prediction):

    if prediction['delay_probability'] > 0.8:

        # High probability of delay

        # Logic to adjust flight schedule or allocate additional resources

        print("Adjusting flight schedule for high delay probability.")

        # This could involve writing to an RDS database, publishing a message to an SNS topic, etc.

Uwaga: Proszę usunąć wszelkie nieużywane usługi AWS, takie jak Sagemaker i lambda, aby uniknąć niepotrzebnych opłat od AWS.