Opplæring: Bruk R til å forutsi flyforsinkelse

Denne opplæringen presenterer et ende-til-ende-eksempel på en Synapse Data Science-arbeidsflyt i Microsoft Fabric. Den bruker nycflights13-dataene , og R, til å forutsi om et fly kommer mer enn 30 minutter for sent. Den bruker deretter prognoseresultatene til å bygge et interaktivt Power BI-instrumentbord.

I denne opplæringen lærer du hvordan du kan gjøre følgende:

• Bruk tidymodelspakker (oppskrifter, analyser, rsample, arbeidsflyter) til å behandle data og lære opp en maskinlæringsmodell
• Skriv utdata til et lakehouse som deltatabell
• Bygg en visualiseringsrapport for Power BI for å få direkte tilgang til data i lakehouse

Forutsetning

• Få et Microsoft Fabric-abonnement. Eller registrer deg for en gratis prøveversjon av Microsoft Fabric.

• Logg på Microsoft Fabric.

• Bruk opplevelsesbryteren til venstre på hjemmesiden for å bytte til Synapse Data Science-opplevelsen.

  

• Åpne eller opprett en notatblokk. Hvis du vil finne ut hvordan du bruker Microsoft Fabric-notatblokker.

• Angi språkalternativet til SparkR (R) for å endre primærspråket.

• Legg notatblokken til et lakehouse. På venstre side velger du Legg til for å legge til et eksisterende innsjøhus eller opprette et innsjøhus.

Installer pakker

Installer nycflights13-pakken for å bruke koden i denne opplæringen.

install.packages("nycflights13")

# Load the packages
library(tidymodels)      # For tidymodels packages
library(nycflights13)    # For flight data

Utforsk dataene

Dataene nycflights13 har informasjon om 325 819 flyvninger som kom nær New York City i 2013. Først kan du se distribusjonen av flyforsinkelser. Denne grafen viser at fordelingen av ankomstforsinkelser er riktig skjev. Den har en lang hale i de høye verdiene.

ggplot(flights, aes(arr_delay)) + geom_histogram(color="blue", bins = 300)

Last inn dataene, og gjør noen endringer i variablene:

set.seed(123)

flight_data <- 
  flights %>% 
  mutate(
    # Convert the arrival delay to a factor
    arr_delay = ifelse(arr_delay >= 30, "late", "on_time"),
    arr_delay = factor(arr_delay),
    # You'll use the date (not date-time) for the recipe that you'll create
    date = lubridate::as_date(time_hour)
  ) %>% 
  # Include weather data
  inner_join(weather, by = c("origin", "time_hour")) %>% 
  # Retain only the specific columns that you'll use
  select(dep_time, flight, origin, dest, air_time, distance, 
         carrier, date, arr_delay, time_hour) %>% 
  # Exclude missing data
  na.omit() %>% 
  # For creating models, it's better to have qualitative columns
  # encoded as factors (instead of character strings)
  mutate_if(is.character, as.factor)

Før vi bygger modellen, bør du vurdere noen spesifikke variabler som er viktige for både forhåndsbehandling og modellering.

Variabel arr_delay er en faktorvariabel. For opplæring av logistisk regresjonsmodell er det viktig at resultatvariabelen er en faktorvariabel.

glimpse(flight_data)

Omtrent 16 % av flyvningene i dette datasettet kom mer enn 30 minutter for sent.

flight_data %>% 
  count(arr_delay) %>% 
  mutate(prop = n/sum(n))

Funksjonen dest har 104 flydestinasjoner.

unique(flight_data$dest)

Det finnes 16 forskjellige operatører.

unique(flight_data$carrier)

Dele dataene

Del enkelt datasett i to sett: et opplæringssett og et testsett . Behold de fleste radene i det opprinnelige datasettet (som et tilfeldig valgt delsett) i opplæringsdatasettet. Bruk opplæringsdatasettet til å tilpasse modellen, og bruk testdatasettet til å måle modellytelsen.

rsample Bruk pakken til å opprette et objekt som inneholder informasjon om hvordan du deler dataene. Bruk deretter to rsample funksjoner til for å opprette DataFrames for opplærings- og testsettene:

set.seed(123)
# Keep most of the data in the training set 
data_split <- initial_split(flight_data, prop = 0.75)

# Create DataFrames for the two sets:
train_data <- training(data_split)
test_data  <- testing(data_split)

Opprette en oppskrift og roller

Lag en oppskrift på en enkel logistisk regresjonsmodell. Før du trener modellen, kan du bruke en oppskrift til å opprette nye prediktorer og gjennomføre forhåndsbearbeidingen som modellen krever.

update_role() Bruk funksjonen slik at oppskriftene vet at flight og time_hour er variabler, med en egendefinert rolle kalt ID. En rolle kan ha en hvilken som helst tegnverdi. Formelen inneholder alle variabler i opplæringssettet, annet enn arr_delay, som prediktorer. Oppskriften beholder disse to ID-variablene, men bruker dem ikke som resultater eller prediktorer.

flights_rec <- 
  recipe(arr_delay ~ ., data = train_data) %>% 
  update_role(flight, time_hour, new_role = "ID") 

Hvis du vil vise gjeldende sett med variabler og roller, bruker du summary() funksjonen:

summary(flights_rec)

Opprette funksjoner

Gjør noen funksjonsteknikker for å forbedre modellen. Flydatoen kan ha en rimelig effekt på sannsynligheten for en sen ankomst.

flight_data %>% 
  distinct(date) %>% 
  mutate(numeric_date = as.numeric(date)) 

Det kan bidra til å legge til modelltermer avledet fra datoen som potensielt har viktighet for modellen. Utled følgende meningsfulle funksjoner fra enkeltdatovariabelen:

• Dag i uken
• Måned
• Hvorvidt datoen tilsvarer en ferie eller ikke

Legg til de tre trinnene i oppskriften:

flights_rec <- 
  recipe(arr_delay ~ ., data = train_data) %>% 
  update_role(flight, time_hour, new_role = "ID") %>% 
  step_date(date, features = c("dow", "month")) %>%               
  step_holiday(date, 
               holidays = timeDate::listHolidays("US"), 
               keep_original_cols = FALSE) %>% 
  step_dummy(all_nominal_predictors()) %>% 
  step_zv(all_predictors())

Tilpass en modell med en oppskrift

Bruk logistisk regresjon til å modellere flydataene. Først bygger du en modellspesifikasjon med parsnip pakken:

lr_mod <- 
  logistic_reg() %>% 
  set_engine("glm")

workflows Bruk pakken til å pakke parsnip modellen (lr_mod) med oppskriften (flights_rec):

flights_wflow <- 
  workflow() %>% 
  add_model(lr_mod) %>% 
  add_recipe(flights_rec)

flights_wflow

Lære opp modellen

Denne funksjonen kan klargjøre oppskriften og lære opp modellen fra de resulterende prediktorene:

flights_fit <- 
  flights_wflow %>% 
  fit(data = train_data)

Bruk hjelpefunksjonene xtract_fit_parsnip() og extract_recipe() til å trekke ut modell- eller oppskriftsobjektene fra arbeidsflyten. I dette eksemplet kan du dra det monterte modellobjektet broom::tidy() , og deretter bruke funksjonen til å få en ryddig tibble av modellskoeffisienter:

flights_fit %>% 
  extract_fit_parsnip() %>% 
  tidy()

Forutsi resultater

Et enkelt kall til å predict() bruke den opplærte arbeidsflyten (flights_fit) til å lage prognoser med de usynlige testdataene. Metoden predict() bruker oppskriften på de nye dataene, og sender deretter resultatene til den monterte modellen.

predict(flights_fit, test_data)

Få utdataene fra predict() for å returnere den forventede klassen: late versus on_time. Men for de forventede klassesannsynlighetene for hver flyvning, bruk augment() med modellen, kombinert med testdata, for å lagre dem sammen:

flights_aug <- 
  augment(flights_fit, test_data)

Se gjennom dataene:

glimpse(flights_aug)

Modellevaluering

Vi har nå en tibble med de forventede klassesannsynlighetene. I de første radene forutså modellen riktig fem flyavganger (verdiene .pred_on_time for er p > 0.50). Vi har imidlertid totalt 81 455 rader å forutsi.

Vi trenger en metrikkverdi som forteller hvor godt modellen forutså sene ankomster, sammenlignet med den sanne statusen til resultatvariabelen. arr_delay

Bruk området under funksjonsegenskapen for kurvemottaker (AUC-ROC) som metrikkverdi. Beregne det med roc_curve() og roc_auc(), fra yardstick pakken:

flights_aug %>% 
  roc_curve(truth = arr_delay, .pred_late) %>% 
  autoplot()

Bygg en Power BI-rapport

Modellresultatet ser bra ut. Bruk prognoseresultatene for flyforsinkelse til å bygge et interaktivt Power BI-instrumentbord. Instrumentbordet viser antall flyvninger etter transportør, og antall flyvninger etter mål. Instrumentbordet kan filtrere etter forsinkelsesprognoseresultatene.

Inkluder navnet på operatøren og flyplassnavnet i prognoseresultatdatasettet:

  flights_clean <- flights_aug %>% 
  # Include the airline data
  left_join(airlines, c("carrier"="carrier"))%>% 
  rename("carrier_name"="name") %>%
  # Include the airport data for origin
  left_join(airports, c("origin"="faa")) %>%
  rename("origin_name"="name") %>%
  # Include the airport data for destination
  left_join(airports, c("dest"="faa")) %>%
  rename("dest_name"="name") %>%
  # Retain only the specific columns you'll use
  select(flight, origin, origin_name, dest,dest_name, air_time,distance, carrier, carrier_name, date, arr_delay, time_hour, .pred_class, .pred_late, .pred_on_time)

Se gjennom dataene:

glimpse(flights_clean)

Konvertere dataene til en Spark DataFrame:

sparkdf <- as.DataFrame(flights_clean)
display(sparkdf)

Skriv inn dataene i en deltatabell i lakehouse:

# Write data into a delta table
temp_delta<-"Tables/nycflight13"
write.df(sparkdf, temp_delta ,source="delta", mode = "overwrite", header = "true")

Bruk deltatabellen til å opprette en semantisk modell.

1. Velg OneLake-datahub til venstre

2. Velg lakehouse som du har knyttet til notatblokken

3. Velg Åpne

   

4. Velg ny semantisk modell

5. Velg nycflight13 for din nye semantiske modell, og velg deretter Bekreft

6. Den semantiske modellen er opprettet. Velg ny rapport

7. Velg eller dra felt fra data- og visualiseringsrutene til rapportlerretet for å bygge rapporten

   

Hvis du vil opprette rapporten som vises i begynnelsen av denne delen, bruker du disse visualiseringene og dataene:

1. Stablet stolpediagram med:
   1. Y-akse: carrier_name
   2. X-akse: fly. Velg Antall for aggregasjonen
   3. Forklaring: origin_name
2. Stablet stolpediagram med:
   1. Y-akse: dest_name
   2. X-akse: fly. Velg Antall for aggregasjonen
   3. Forklaring: origin_name
3. Slicer med:
   1. Felt: _pred_class
4. Slicer med:
   1. Felt: _pred_late

Relatert innhold

• Slik bruker du SparkR
• Slik bruker du sparklyr
• Slik bruker du Tidyverse
• Administrasjon av R-bibliotek
• Visualiser data i R
• Opplæring: Bruk R til å forutsi avokadopriser