You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1083 lines
43 KiB
1083 lines
43 KiB
{
|
|
"nbformat": 4,
|
|
"nbformat_minor": 2,
|
|
"metadata": {
|
|
"colab": {
|
|
"name": "lesson_3-R.ipynb",
|
|
"provenance": [],
|
|
"collapsed_sections": [],
|
|
"toc_visible": true
|
|
},
|
|
"kernelspec": {
|
|
"name": "ir",
|
|
"display_name": "R"
|
|
},
|
|
"language_info": {
|
|
"name": "R"
|
|
},
|
|
"coopTranslator": {
|
|
"original_hash": "5015d65d61ba75a223bfc56c273aa174",
|
|
"translation_date": "2025-08-29T22:57:26+00:00",
|
|
"source_file": "2-Regression/3-Linear/solution/R/lesson_3-R.ipynb",
|
|
"language_code": "it"
|
|
}
|
|
},
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [],
|
|
"metadata": {
|
|
"id": "EgQw8osnsUV-"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"## Regressione Lineare e Polinomiale per il Prezzo delle Zucche - Lezione 3\n",
|
|
"<p >\n",
|
|
" <img src=\"../../images/linear-polynomial.png\"\n",
|
|
" width=\"800\"/>\n",
|
|
" <figcaption>Infografica di Dasani Madipalli</figcaption>\n",
|
|
"\n",
|
|
"\n",
|
|
"<!--{width=\"800\"}-->\n",
|
|
"\n",
|
|
"#### Introduzione\n",
|
|
"\n",
|
|
"Finora hai esplorato cosa sia la regressione utilizzando dati di esempio raccolti dal dataset sui prezzi delle zucche che useremo per tutta questa lezione. Hai anche visualizzato i dati con `ggplot2`. 💪\n",
|
|
"\n",
|
|
"Ora sei pronto per approfondire la regressione per il Machine Learning. In questa lezione, imparerai di più su due tipi di regressione: *regressione lineare di base* e *regressione polinomiale*, insieme ad alcune nozioni matematiche alla base di queste tecniche.\n",
|
|
"\n",
|
|
"> In tutto questo curriculum, assumiamo una conoscenza minima della matematica e cerchiamo di renderla accessibile agli studenti provenienti da altri campi. Fai attenzione a note, 🧮 richiami, diagrammi e altri strumenti di apprendimento per facilitare la comprensione.\n",
|
|
"\n",
|
|
"#### Preparazione\n",
|
|
"\n",
|
|
"Come promemoria, stai caricando questi dati per porre loro delle domande.\n",
|
|
"\n",
|
|
"- Qual è il momento migliore per comprare le zucche?\n",
|
|
"\n",
|
|
"- Quale prezzo posso aspettarmi per una cassa di zucche in miniatura?\n",
|
|
"\n",
|
|
"- Dovrei comprarle in cesti da mezzo bushel o in scatole da 1 1/9 di bushel? Continuiamo a scavare in questi dati.\n",
|
|
"\n",
|
|
"Nella lezione precedente, hai creato un `tibble` (una moderna reinterpretazione del data frame) e lo hai popolato con una parte del dataset originale, standardizzando i prezzi per bushel. Facendo ciò, tuttavia, sei riuscito a raccogliere solo circa 400 punti dati e solo per i mesi autunnali. Forse possiamo ottenere un po' più di dettagli sulla natura dei dati pulendoli ulteriormente? Vedremo... 🕵️♀️\n",
|
|
"\n",
|
|
"Per questo compito, avremo bisogno dei seguenti pacchetti:\n",
|
|
"\n",
|
|
"- `tidyverse`: Il [tidyverse](https://www.tidyverse.org/) è una [collezione di pacchetti R](https://www.tidyverse.org/packages) progettata per rendere la scienza dei dati più veloce, facile e divertente!\n",
|
|
"\n",
|
|
"- `tidymodels`: Il framework [tidymodels](https://www.tidymodels.org/) è una [collezione di pacchetti](https://www.tidymodels.org/packages/) per la modellazione e il machine learning.\n",
|
|
"\n",
|
|
"- `janitor`: Il pacchetto [janitor](https://github.com/sfirke/janitor) fornisce semplici strumenti per esaminare e pulire dati disordinati.\n",
|
|
"\n",
|
|
"- `corrplot`: Il pacchetto [corrplot](https://cran.r-project.org/web/packages/corrplot/vignettes/corrplot-intro.html) offre uno strumento visivo esplorativo per la matrice di correlazione, supportando il riordino automatico delle variabili per aiutare a rilevare schemi nascosti tra le variabili.\n",
|
|
"\n",
|
|
"Puoi installarli con il seguente comando:\n",
|
|
"\n",
|
|
"`install.packages(c(\"tidyverse\", \"tidymodels\", \"janitor\", \"corrplot\"))`\n",
|
|
"\n",
|
|
"Lo script qui sotto verifica se hai i pacchetti necessari per completare questo modulo e li installa per te nel caso in cui manchino.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "WqQPS1OAsg3H"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"suppressWarnings(if (!require(\"pacman\")) install.packages(\"pacman\"))\n",
|
|
"\n",
|
|
"pacman::p_load(tidyverse, tidymodels, janitor, corrplot)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "tA4C2WN3skCf",
|
|
"colab": {
|
|
"base_uri": "https://localhost:8080/"
|
|
},
|
|
"outputId": "c06cd805-5534-4edc-f72b-d0d1dab96ac0"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Caricheremo successivamente questi fantastici pacchetti e li renderemo disponibili nella nostra sessione R corrente. (Questo è solo a scopo illustrativo, `pacman::p_load()` lo ha già fatto per te)\n",
|
|
"\n",
|
|
"## 1. Una linea di regressione lineare\n",
|
|
"\n",
|
|
"Come hai imparato nella Lezione 1, l'obiettivo di un esercizio di regressione lineare è essere in grado di tracciare una *linea* *di* *miglior adattamento* per:\n",
|
|
"\n",
|
|
"- **Mostrare le relazioni tra variabili**. Mostrare la relazione tra le variabili.\n",
|
|
"\n",
|
|
"- **Fare previsioni**. Fare previsioni accurate su dove un nuovo punto dati potrebbe cadere in relazione a quella linea.\n",
|
|
"\n",
|
|
"Per disegnare questo tipo di linea, utilizziamo una tecnica statistica chiamata **Regressione dei Minimi Quadrati**. Il termine `minimi quadrati` significa che tutti i punti dati che circondano la linea di regressione vengono elevati al quadrato e poi sommati. Idealmente, quella somma finale è il più piccola possibile, perché vogliamo un numero basso di errori, o `minimi quadrati`. Pertanto, la linea di miglior adattamento è la linea che ci dà il valore più basso per la somma degli errori al quadrato - da qui il nome *regressione dei minimi quadrati*.\n",
|
|
"\n",
|
|
"Facciamo questo perché vogliamo modellare una linea che abbia la minima distanza cumulativa da tutti i nostri punti dati. Inoltre, eleviamo al quadrato i termini prima di sommarli poiché ci interessa la loro grandezza piuttosto che la loro direzione.\n",
|
|
"\n",
|
|
"> **🧮 Mostrami la matematica**\n",
|
|
">\n",
|
|
"> Questa linea, chiamata *linea di miglior adattamento*, può essere espressa da [un'equazione](https://en.wikipedia.org/wiki/Simple_linear_regression):\n",
|
|
">\n",
|
|
"> Y = a + bX\n",
|
|
">\n",
|
|
"> `X` è la '`variabile esplicativa` o `predittore`'. `Y` è la '`variabile dipendente` o `risultato`'. La pendenza della linea è `b` e `a` è l'intercetta sull'asse y, che si riferisce al valore di `Y` quando `X = 0`.\n",
|
|
">\n",
|
|
"\n",
|
|
"> ![](../../../../../../2-Regression/3-Linear/solution/images/slope.png \"pendenza = $y/x$\")\n",
|
|
" Infografica di Jen Looper\n",
|
|
">\n",
|
|
"> Per prima cosa, calcola la pendenza `b`.\n",
|
|
">\n",
|
|
"> In altre parole, e riferendoci alla domanda originale sui dati delle zucche: \"prevedere il prezzo di una zucca per bushel in base al mese\", `X` si riferirebbe al prezzo e `Y` si riferirebbe al mese di vendita.\n",
|
|
">\n",
|
|
"> \n",
|
|
" Infografica di Jen Looper\n",
|
|
"> \n",
|
|
"> Calcola il valore di Y. Se stai pagando circa \\$4, deve essere aprile!\n",
|
|
">\n",
|
|
"> La matematica che calcola la linea deve dimostrare la pendenza della linea, che dipende anche dall'intercetta, ovvero dove si trova `Y` quando `X = 0`.\n",
|
|
">\n",
|
|
"> Puoi osservare il metodo di calcolo per questi valori sul sito web [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html). Visita anche [questo calcolatore dei minimi quadrati](https://www.mathsisfun.com/data/least-squares-calculator.html) per vedere come i valori numerici influenzano la linea.\n",
|
|
"\n",
|
|
"Non così spaventoso, vero? 🤓\n",
|
|
"\n",
|
|
"#### Correlazione\n",
|
|
"\n",
|
|
"Un altro termine da comprendere è il **Coefficiente di Correlazione** tra le variabili X e Y date. Utilizzando un diagramma a dispersione, puoi visualizzare rapidamente questo coefficiente. Un grafico con punti dati distribuiti in una linea ordinata ha alta correlazione, mentre un grafico con punti dati distribuiti ovunque tra X e Y ha bassa correlazione.\n",
|
|
"\n",
|
|
"Un buon modello di regressione lineare sarà quello che ha un alto Coefficiente di Correlazione (più vicino a 1 che a 0) utilizzando il metodo della Regressione dei Minimi Quadrati con una linea di regressione.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "cdX5FRpvsoP5"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"## **2. Una danza con i dati: creare un data frame che verrà utilizzato per la modellazione**\n",
|
|
"\n",
|
|
"<p >\n",
|
|
" <img src=\"../../images/janitor.jpg\"\n",
|
|
" width=\"700\"/>\n",
|
|
" <figcaption>Opera d'arte di @allison_horst</figcaption>\n",
|
|
"\n",
|
|
"\n",
|
|
"<!--{width=\"700\"}-->\n"
|
|
],
|
|
"metadata": {
|
|
"id": "WdUKXk7Bs8-V"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Carica le librerie necessarie e il dataset. Converti i dati in un data frame contenente un sottoinsieme dei dati:\n",
|
|
"\n",
|
|
"- Considera solo le zucche con prezzo al bushel\n",
|
|
"\n",
|
|
"- Converti la data in un mese\n",
|
|
"\n",
|
|
"- Calcola il prezzo come media tra il prezzo massimo e minimo\n",
|
|
"\n",
|
|
"- Converti il prezzo per riflettere la quantità al bushel\n",
|
|
"\n",
|
|
"> Abbiamo trattato questi passaggi nella [lezione precedente](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/2-Data/solution/lesson_2-R.ipynb).\n"
|
|
],
|
|
"metadata": {
|
|
"id": "fMCtu2G2s-p8"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Load the core Tidyverse packages\n",
|
|
"library(tidyverse)\n",
|
|
"library(lubridate)\n",
|
|
"\n",
|
|
"# Import the pumpkins data\n",
|
|
"pumpkins <- read_csv(file = \"https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/2-Regression/data/US-pumpkins.csv\")\n",
|
|
"\n",
|
|
"\n",
|
|
"# Get a glimpse and dimensions of the data\n",
|
|
"glimpse(pumpkins)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Print the first 50 rows of the data set\n",
|
|
"pumpkins %>% \n",
|
|
" slice_head(n = 5)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "ryMVZEEPtERn"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Nello spirito della pura avventura, esploriamo il [`pacchetto janitor`](../../../../../../2-Regression/3-Linear/solution/R/github.com/sfirke/janitor) che fornisce funzioni semplici per esaminare e pulire dati sporchi. Ad esempio, diamo un'occhiata ai nomi delle colonne dei nostri dati:\n"
|
|
],
|
|
"metadata": {
|
|
"id": "xcNxM70EtJjb"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Return column names\n",
|
|
"pumpkins %>% \n",
|
|
" names()"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "5XtpaIigtPfW"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"🤔 Possiamo fare meglio. Convertiamo questi nomi di colonna in `friendR` utilizzando la convenzione [snake_case](https://en.wikipedia.org/wiki/Snake_case) con `janitor::clean_names`. Per saperne di più su questa funzione: `?clean_names`\n"
|
|
],
|
|
"metadata": {
|
|
"id": "IbIqrMINtSHe"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Clean names to the snake_case convention\n",
|
|
"pumpkins <- pumpkins %>% \n",
|
|
" clean_names(case = \"snake\")\n",
|
|
"\n",
|
|
"# Return column names\n",
|
|
"pumpkins %>% \n",
|
|
" names()"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "a2uYvclYtWvX"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Molto tidyR 🧹! Ora, un ballo con i dati usando `dplyr` come nella lezione precedente! 💃\n"
|
|
],
|
|
"metadata": {
|
|
"id": "HfhnuzDDtaDd"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Select desired columns\n",
|
|
"pumpkins <- pumpkins %>% \n",
|
|
" select(variety, city_name, package, low_price, high_price, date)\n",
|
|
"\n",
|
|
"\n",
|
|
"\n",
|
|
"# Extract the month from the dates to a new column\n",
|
|
"pumpkins <- pumpkins %>%\n",
|
|
" mutate(date = mdy(date),\n",
|
|
" month = month(date)) %>% \n",
|
|
" select(-date)\n",
|
|
"\n",
|
|
"\n",
|
|
"\n",
|
|
"# Create a new column for average Price\n",
|
|
"pumpkins <- pumpkins %>% \n",
|
|
" mutate(price = (low_price + high_price)/2)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Retain only pumpkins with the string \"bushel\"\n",
|
|
"new_pumpkins <- pumpkins %>% \n",
|
|
" filter(str_detect(string = package, pattern = \"bushel\"))\n",
|
|
"\n",
|
|
"\n",
|
|
"# Normalize the pricing so that you show the pricing per bushel, not per 1 1/9 or 1/2 bushel\n",
|
|
"new_pumpkins <- new_pumpkins %>% \n",
|
|
" mutate(price = case_when(\n",
|
|
" str_detect(package, \"1 1/9\") ~ price/(1.1),\n",
|
|
" str_detect(package, \"1/2\") ~ price*2,\n",
|
|
" TRUE ~ price))\n",
|
|
"\n",
|
|
"# Relocate column positions\n",
|
|
"new_pumpkins <- new_pumpkins %>% \n",
|
|
" relocate(month, .before = variety)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Display the first 5 rows\n",
|
|
"new_pumpkins %>% \n",
|
|
" slice_head(n = 5)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "X0wU3gQvtd9f"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Ottimo lavoro!👌 Ora hai un set di dati pulito e ordinato su cui puoi costruire il tuo nuovo modello di regressione!\n",
|
|
"\n",
|
|
"Che ne dici di un grafico a dispersione?\n"
|
|
],
|
|
"metadata": {
|
|
"id": "UpaIwaxqth82"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Set theme\n",
|
|
"theme_set(theme_light())\n",
|
|
"\n",
|
|
"# Make a scatter plot of month and price\n",
|
|
"new_pumpkins %>% \n",
|
|
" ggplot(mapping = aes(x = month, y = price)) +\n",
|
|
" geom_point(size = 1.6)\n"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "DXgU-j37tl5K"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Un grafico a dispersione ci ricorda che abbiamo dati mensili solo da agosto a dicembre. Probabilmente abbiamo bisogno di più dati per poter trarre conclusioni in modo lineare.\n",
|
|
"\n",
|
|
"Diamo un'occhiata di nuovo ai nostri dati di modellazione:\n"
|
|
],
|
|
"metadata": {
|
|
"id": "Ve64wVbwtobI"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Display first 5 rows\n",
|
|
"new_pumpkins %>% \n",
|
|
" slice_head(n = 5)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "HFQX2ng1tuSJ"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"E se volessimo prevedere il `prezzo` di una zucca basandoci sulle colonne `città` o `pacchetto`, che sono di tipo carattere? Oppure, ancora più semplicemente, come potremmo trovare la correlazione (che richiede che entrambi i suoi input siano numerici) tra, ad esempio, `pacchetto` e `prezzo`? 🤷🤷\n",
|
|
"\n",
|
|
"I modelli di machine learning funzionano meglio con caratteristiche numeriche piuttosto che con valori testuali, quindi in genere è necessario convertire le caratteristiche categoriche in rappresentazioni numeriche.\n",
|
|
"\n",
|
|
"Questo significa che dobbiamo trovare un modo per riformattare i nostri predittori per renderli più facili da utilizzare efficacemente da un modello, un processo noto come `feature engineering`.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "7hsHoxsStyjJ"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"## 3. Pre-elaborazione dei dati per la modellazione con recipes 👩🍳👨🍳\n",
|
|
"\n",
|
|
"Le attività che riformattano i valori dei predittori per renderli più facili da utilizzare efficacemente da un modello sono chiamate `feature engineering`.\n",
|
|
"\n",
|
|
"Modelli diversi hanno requisiti di pre-elaborazione differenti. Ad esempio, i minimi quadrati richiedono `l'encoding delle variabili categoriche` come mese, varietà e city_name. Questo implica semplicemente `tradurre` una colonna con `valori categorici` in una o più `colonne numeriche` che sostituiscono l'originale.\n",
|
|
"\n",
|
|
"Ad esempio, supponiamo che i tuoi dati includano la seguente caratteristica categorica:\n",
|
|
"\n",
|
|
"| city |\n",
|
|
"|:-------:|\n",
|
|
"| Denver |\n",
|
|
"| Nairobi |\n",
|
|
"| Tokyo |\n",
|
|
"\n",
|
|
"Puoi applicare l'*ordinal encoding* per sostituire ogni categoria con un valore intero unico, come questo:\n",
|
|
"\n",
|
|
"| city |\n",
|
|
"|:----:|\n",
|
|
"| 0 |\n",
|
|
"| 1 |\n",
|
|
"| 2 |\n",
|
|
"\n",
|
|
"Ed è proprio quello che faremo con i nostri dati!\n",
|
|
"\n",
|
|
"In questa sezione, esploreremo un altro fantastico pacchetto di Tidymodels: [recipes](https://tidymodels.github.io/recipes/) - progettato per aiutarti a pre-elaborare i tuoi dati **prima** di addestrare il tuo modello. Alla base, una recipe è un oggetto che definisce quali passaggi devono essere applicati a un set di dati per prepararlo alla modellazione.\n",
|
|
"\n",
|
|
"Ora, creiamo una recipe che prepara i nostri dati per la modellazione sostituendo un intero unico per tutte le osservazioni nelle colonne dei predittori:\n"
|
|
],
|
|
"metadata": {
|
|
"id": "AD5kQbcvt3Xl"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Specify a recipe\n",
|
|
"pumpkins_recipe <- recipe(price ~ ., data = new_pumpkins) %>% \n",
|
|
" step_integer(all_predictors(), zero_based = TRUE)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Print out the recipe\n",
|
|
"pumpkins_recipe"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "BNaFKXfRt9TU"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Fantastico! 👏 Abbiamo appena creato la nostra prima ricetta che specifica un risultato (prezzo) e i suoi corrispondenti predittori, e che tutte le colonne dei predittori devono essere codificate in un set di numeri interi 🙌! Analizziamola rapidamente:\n",
|
|
"\n",
|
|
"- La chiamata a `recipe()` con una formula indica alla ricetta i *ruoli* delle variabili utilizzando i dati di `new_pumpkins` come riferimento. Ad esempio, la colonna `price` è stata assegnata al ruolo di `outcome`, mentre il resto delle colonne è stato assegnato al ruolo di `predictor`.\n",
|
|
"\n",
|
|
"- `step_integer(all_predictors(), zero_based = TRUE)` specifica che tutti i predittori devono essere convertiti in un set di numeri interi, con la numerazione che parte da 0.\n",
|
|
"\n",
|
|
"Siamo sicuri che potresti avere pensieri del tipo: \"È fantastico!! Ma cosa succede se avessi bisogno di confermare che le ricette stanno facendo esattamente ciò che mi aspetto? 🤔\"\n",
|
|
"\n",
|
|
"È un pensiero eccellente! Vedi, una volta definita la tua ricetta, puoi stimare i parametri necessari per preprocessare effettivamente i dati e poi estrarre i dati elaborati. Non è qualcosa che fai tipicamente quando usi Tidymodels (vedremo la convenzione normale tra poco-\\> `workflows`), ma può essere utile quando vuoi fare un controllo di coerenza per confermare che le ricette stiano facendo ciò che ti aspetti.\n",
|
|
"\n",
|
|
"Per questo, avrai bisogno di due verbi aggiuntivi: `prep()` e `bake()`, e come sempre, i nostri piccoli amici di R di [`Allison Horst`](https://github.com/allisonhorst/stats-illustrations) ti aiutano a capire meglio!\n",
|
|
"\n",
|
|
"<p >\n",
|
|
" <img src=\"../../images/recipes.png\"\n",
|
|
" width=\"550\"/>\n",
|
|
" <figcaption>Illustrazione di @allison_horst</figcaption>\n"
|
|
],
|
|
"metadata": {
|
|
"id": "KEiO0v7kuC9O"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"[`prep()`](https://recipes.tidymodels.org/reference/prep.html): stima i parametri necessari da un set di addestramento che possono essere successivamente applicati ad altri set di dati. Ad esempio, per una determinata colonna predittore, quale osservazione verrà assegnata all'intero 0, 1, 2, ecc.\n",
|
|
"\n",
|
|
"[`bake()`](https://recipes.tidymodels.org/reference/bake.html): prende una ricetta preparata e applica le operazioni a qualsiasi set di dati.\n",
|
|
"\n",
|
|
"Detto ciò, prepariamo e applichiamo le nostre ricette per confermare davvero che, dietro le quinte, le colonne predittore saranno prima codificate prima che un modello venga adattato.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "Q1xtzebuuTCP"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Prep the recipe\n",
|
|
"pumpkins_prep <- prep(pumpkins_recipe)\n",
|
|
"\n",
|
|
"# Bake the recipe to extract a preprocessed new_pumpkins data\n",
|
|
"baked_pumpkins <- bake(pumpkins_prep, new_data = NULL)\n",
|
|
"\n",
|
|
"# Print out the baked data set\n",
|
|
"baked_pumpkins %>% \n",
|
|
" slice_head(n = 10)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "FGBbJbP_uUUn"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Evviva! 🥳 I dati elaborati `baked_pumpkins` hanno tutti i loro predittori codificati, confermando che i passaggi di preprocessing definiti come la nostra ricetta funzioneranno come previsto. Questo li rende più difficili da leggere per te, ma molto più comprensibili per Tidymodels! Prenditi un po' di tempo per scoprire quale osservazione è stata mappata a un intero corrispondente.\n",
|
|
"\n",
|
|
"Vale anche la pena menzionare che `baked_pumpkins` è un data frame su cui possiamo eseguire calcoli.\n",
|
|
"\n",
|
|
"Ad esempio, proviamo a trovare una buona correlazione tra due punti dei tuoi dati per potenzialmente costruire un buon modello predittivo. Useremo la funzione `cor()` per farlo. Digita `?cor()` per scoprire di più sulla funzione.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "1dvP0LBUueAW"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Find the correlation between the city_name and the price\n",
|
|
"cor(baked_pumpkins$city_name, baked_pumpkins$price)\n",
|
|
"\n",
|
|
"# Find the correlation between the package and the price\n",
|
|
"cor(baked_pumpkins$package, baked_pumpkins$price)\n"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "3bQzXCjFuiSV"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"A quanto pare, c'è solo una debole correlazione tra la Città e il Prezzo. Tuttavia, c'è una correlazione un po' migliore tra il Pacchetto e il suo Prezzo. Ha senso, vero? Normalmente, più grande è la scatola di prodotti, più alto è il prezzo.\n",
|
|
"\n",
|
|
"Già che ci siamo, proviamo anche a visualizzare una matrice di correlazione di tutte le colonne utilizzando il pacchetto `corrplot`.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "BToPWbgjuoZw"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Load the corrplot package\n",
|
|
"library(corrplot)\n",
|
|
"\n",
|
|
"# Obtain correlation matrix\n",
|
|
"corr_mat <- cor(baked_pumpkins %>% \n",
|
|
" # Drop columns that are not really informative\n",
|
|
" select(-c(low_price, high_price)))\n",
|
|
"\n",
|
|
"# Make a correlation plot between the variables\n",
|
|
"corrplot(corr_mat, method = \"shade\", shade.col = NA, tl.col = \"black\", tl.srt = 45, addCoef.col = \"black\", cl.pos = \"n\", order = \"original\")"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "ZwAL3ksmutVR"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"🤩🤩 Molto meglio.\n",
|
|
"\n",
|
|
"Una buona domanda da porre ora a questi dati potrebbe essere: '`Quale prezzo posso aspettarmi per un determinato pacchetto di zucche?`' Andiamo subito al dunque!\n",
|
|
"\n",
|
|
"> Nota: Quando **`bake()`** la ricetta preparata **`pumpkins_prep`** con **`new_data = NULL`**, estrai i dati di addestramento elaborati (cioè codificati). Se avessi un altro set di dati, ad esempio un set di test, e volessi vedere come una ricetta lo pre-processerebbe, ti basterebbe fare il bake di **`pumpkins_prep`** con **`new_data = test_set`**.\n",
|
|
"\n",
|
|
"## 4. Costruire un modello di regressione lineare\n",
|
|
"\n",
|
|
"<p >\n",
|
|
" <img src=\"../../images/linear-polynomial.png\"\n",
|
|
" width=\"800\"/>\n",
|
|
" <figcaption>Infografica di Dasani Madipalli</figcaption>\n"
|
|
],
|
|
"metadata": {
|
|
"id": "YqXjLuWavNxW"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Ora che abbiamo creato una ricetta e confermato che i dati verranno pre-processati correttamente, passiamo a costruire un modello di regressione per rispondere alla domanda: `Quale prezzo posso aspettarmi per un determinato pacchetto di zucca?`\n",
|
|
"\n",
|
|
"#### Addestrare un modello di regressione lineare utilizzando il set di addestramento\n",
|
|
"\n",
|
|
"Come avrai già intuito, la colonna *price* è la variabile `outcome`, mentre la colonna *package* è la variabile `predictor`.\n",
|
|
"\n",
|
|
"Per fare ciò, inizieremo dividendo i dati in modo che l'80% vada nel set di addestramento e il 20% nel set di test, poi definiremo una ricetta che codificherà la colonna predictor in un insieme di interi, quindi costruiremo una specifica del modello. Non prepareremo e non cuoceremo la nostra ricetta, poiché sappiamo già che pre-processerà i dati come previsto.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "Pq0bSzCevW-h"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"set.seed(2056)\n",
|
|
"# Split the data into training and test sets\n",
|
|
"pumpkins_split <- new_pumpkins %>% \n",
|
|
" initial_split(prop = 0.8)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Extract training and test data\n",
|
|
"pumpkins_train <- training(pumpkins_split)\n",
|
|
"pumpkins_test <- testing(pumpkins_split)\n",
|
|
"\n",
|
|
"\n",
|
|
"\n",
|
|
"# Create a recipe for preprocessing the data\n",
|
|
"lm_pumpkins_recipe <- recipe(price ~ package, data = pumpkins_train) %>% \n",
|
|
" step_integer(all_predictors(), zero_based = TRUE)\n",
|
|
"\n",
|
|
"\n",
|
|
"\n",
|
|
"# Create a linear model specification\n",
|
|
"lm_spec <- linear_reg() %>% \n",
|
|
" set_engine(\"lm\") %>% \n",
|
|
" set_mode(\"regression\")"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "CyoEh_wuvcLv"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Ottimo lavoro! Ora che abbiamo una ricetta e una specifica del modello, dobbiamo trovare un modo per unirle in un oggetto che prima pre-elabori i dati (prep+bake dietro le quinte), adatti il modello ai dati pre-elaborati e consenta anche eventuali attività di post-elaborazione. Che ne dici per la tua tranquillità!🤩\n",
|
|
"\n",
|
|
"In Tidymodels, questo pratico oggetto si chiama [`workflow`](https://workflows.tidymodels.org/) e contiene comodamente i tuoi componenti di modellazione! Questo è ciò che chiameremmo *pipeline* in *Python*.\n",
|
|
"\n",
|
|
"Quindi, mettiamo tutto insieme in un workflow!📦\n"
|
|
],
|
|
"metadata": {
|
|
"id": "G3zF_3DqviFJ"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Hold modelling components in a workflow\n",
|
|
"lm_wf <- workflow() %>% \n",
|
|
" add_recipe(lm_pumpkins_recipe) %>% \n",
|
|
" add_model(lm_spec)\n",
|
|
"\n",
|
|
"# Print out the workflow\n",
|
|
"lm_wf"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "T3olroU3v-WX"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Inoltre, un workflow può essere adattato/allenato nello stesso modo in cui può esserlo un modello.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "zd1A5tgOwEPX"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Train the model\n",
|
|
"lm_wf_fit <- lm_wf %>% \n",
|
|
" fit(data = pumpkins_train)\n",
|
|
"\n",
|
|
"# Print the model coefficients learned \n",
|
|
"lm_wf_fit"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "NhJagFumwFHf"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Dai coefficienti ottenuti durante l'addestramento, possiamo osservare i valori appresi. Essi rappresentano i coefficienti della retta di miglior adattamento che ci fornisce l'errore complessivo più basso tra la variabile reale e quella predetta.\n",
|
|
"\n",
|
|
"#### Valutare le prestazioni del modello utilizzando il set di test\n",
|
|
"\n",
|
|
"È il momento di vedere come si è comportato il modello 📏! Come possiamo farlo?\n",
|
|
"\n",
|
|
"Ora che abbiamo addestrato il modello, possiamo utilizzarlo per fare previsioni sul `test_set` usando `parsnip::predict()`. Successivamente, possiamo confrontare queste previsioni con i valori effettivi delle etichette per valutare quanto bene (o meno!) il modello stia funzionando.\n",
|
|
"\n",
|
|
"Iniziamo facendo previsioni per il set di test e poi uniamo le colonne al set di test.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "_4QkGtBTwItF"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Make predictions for the test set\n",
|
|
"predictions <- lm_wf_fit %>% \n",
|
|
" predict(new_data = pumpkins_test)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Bind predictions to the test set\n",
|
|
"lm_results <- pumpkins_test %>% \n",
|
|
" select(c(package, price)) %>% \n",
|
|
" bind_cols(predictions)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Print the first ten rows of the tibble\n",
|
|
"lm_results %>% \n",
|
|
" slice_head(n = 10)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "UFZzTG0gwTs9"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Sì, hai appena addestrato un modello e lo hai utilizzato per fare previsioni! 🔮 È valido? Valutiamo le prestazioni del modello!\n",
|
|
"\n",
|
|
"In Tidymodels, lo facciamo utilizzando `yardstick::metrics()`! Per la regressione lineare, concentriamoci sui seguenti indicatori:\n",
|
|
"\n",
|
|
"- `Root Mean Square Error (RMSE)`: La radice quadrata del [MSE](https://en.wikipedia.org/wiki/Mean_squared_error). Questo fornisce una metrica assoluta nella stessa unità dell'etichetta (in questo caso, il prezzo di una zucca). Più piccolo è il valore, migliore è il modello (in termini semplici, rappresenta il prezzo medio di errore delle previsioni!).\n",
|
|
"\n",
|
|
"- `Coefficient of Determination (di solito noto come R-squared o R2)`: Una metrica relativa in cui un valore più alto indica una migliore aderenza del modello. In sostanza, questa metrica rappresenta quanto della varianza tra i valori previsti e quelli reali delle etichette il modello è in grado di spiegare.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "0A5MjzM7wW9M"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Evaluate performance of linear regression\n",
|
|
"metrics(data = lm_results,\n",
|
|
" truth = price,\n",
|
|
" estimate = .pred)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "reJ0UIhQwcEH"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Ecco che la performance del modello cala. Vediamo se possiamo ottenere un'indicazione migliore visualizzando un grafico a dispersione del pacchetto e del prezzo, quindi utilizzando le previsioni fatte per sovrapporre una linea di miglior adattamento.\n",
|
|
"\n",
|
|
"Questo significa che dovremo preparare e trasformare il set di test per codificare la colonna del pacchetto, quindi unire questo alle previsioni fatte dal nostro modello.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "fdgjzjkBwfWt"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Encode package column\n",
|
|
"package_encode <- lm_pumpkins_recipe %>% \n",
|
|
" prep() %>% \n",
|
|
" bake(new_data = pumpkins_test) %>% \n",
|
|
" select(package)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Bind encoded package column to the results\n",
|
|
"lm_results <- lm_results %>% \n",
|
|
" bind_cols(package_encode %>% \n",
|
|
" rename(package_integer = package)) %>% \n",
|
|
" relocate(package_integer, .after = package)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Print new results data frame\n",
|
|
"lm_results %>% \n",
|
|
" slice_head(n = 5)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Make a scatter plot\n",
|
|
"lm_results %>% \n",
|
|
" ggplot(mapping = aes(x = package_integer, y = price)) +\n",
|
|
" geom_point(size = 1.6) +\n",
|
|
" # Overlay a line of best fit\n",
|
|
" geom_line(aes(y = .pred), color = \"orange\", size = 1.2) +\n",
|
|
" xlab(\"package\")\n",
|
|
" \n"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "R0nw719lwkHE"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Fantastico! Come puoi vedere, il modello di regressione lineare non generalizza molto bene la relazione tra un pacchetto e il suo prezzo corrispondente.\n",
|
|
"\n",
|
|
"🎃 Congratulazioni, hai appena creato un modello che può aiutarti a prevedere il prezzo di alcune varietà di zucche. Il tuo campo di zucche per le festività sarà splendido. Ma probabilmente puoi creare un modello migliore!\n",
|
|
"\n",
|
|
"## 5. Costruisci un modello di regressione polinomiale\n",
|
|
"\n",
|
|
"<p >\n",
|
|
" <img src=\"../../images/linear-polynomial.png\"\n",
|
|
" width=\"800\"/>\n",
|
|
" <figcaption>Infografica di Dasani Madipalli</figcaption>\n",
|
|
"\n",
|
|
"\n",
|
|
"<!--{width=\"800\"}-->\n"
|
|
],
|
|
"metadata": {
|
|
"id": "HOCqJXLTwtWI"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"A volte i nostri dati potrebbero non avere una relazione lineare, ma vogliamo comunque prevedere un risultato. La regressione polinomiale può aiutarci a fare previsioni per relazioni non lineari più complesse.\n",
|
|
"\n",
|
|
"Prendiamo, ad esempio, la relazione tra il pacchetto e il prezzo nel nostro set di dati sulle zucche. Sebbene a volte ci sia una relazione lineare tra le variabili - più grande è la zucca in volume, più alto è il prezzo - a volte queste relazioni non possono essere rappresentate come un piano o una linea retta.\n",
|
|
"\n",
|
|
"> ✅ Ecco [alcuni altri esempi](https://online.stat.psu.edu/stat501/lesson/9/9.8) di dati che potrebbero utilizzare la regressione polinomiale\n",
|
|
">\n",
|
|
"> Dai un'altra occhiata alla relazione tra Varietà e Prezzo nel grafico precedente. Questo scatterplot sembra necessariamente analizzabile con una linea retta? Forse no. In questo caso, puoi provare la regressione polinomiale.\n",
|
|
">\n",
|
|
"> ✅ I polinomi sono espressioni matematiche che possono consistere in una o più variabili e coefficienti\n",
|
|
"\n",
|
|
"#### Addestrare un modello di regressione polinomiale utilizzando il set di addestramento\n",
|
|
"\n",
|
|
"La regressione polinomiale crea una *linea curva* per adattarsi meglio ai dati non lineari.\n",
|
|
"\n",
|
|
"Vediamo se un modello polinomiale offrirà prestazioni migliori nel fare previsioni. Seguiremo una procedura abbastanza simile a quella che abbiamo seguito in precedenza:\n",
|
|
"\n",
|
|
"- Creare una ricetta che specifichi i passaggi di pre-elaborazione da eseguire sui nostri dati per prepararli alla modellazione, ad esempio: codificare i predittori e calcolare i polinomi di grado *n*\n",
|
|
"\n",
|
|
"- Costruire una specifica del modello\n",
|
|
"\n",
|
|
"- Combinare la ricetta e la specifica del modello in un flusso di lavoro\n",
|
|
"\n",
|
|
"- Creare un modello adattando il flusso di lavoro\n",
|
|
"\n",
|
|
"- Valutare quanto bene il modello si comporta sui dati di test\n",
|
|
"\n",
|
|
"Iniziamo subito!\n"
|
|
],
|
|
"metadata": {
|
|
"id": "VcEIpRV9wzYr"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Specify a recipe\r\n",
|
|
"poly_pumpkins_recipe <-\r\n",
|
|
" recipe(price ~ package, data = pumpkins_train) %>%\r\n",
|
|
" step_integer(all_predictors(), zero_based = TRUE) %>% \r\n",
|
|
" step_poly(all_predictors(), degree = 4)\r\n",
|
|
"\r\n",
|
|
"\r\n",
|
|
"# Create a model specification\r\n",
|
|
"poly_spec <- linear_reg() %>% \r\n",
|
|
" set_engine(\"lm\") %>% \r\n",
|
|
" set_mode(\"regression\")\r\n",
|
|
"\r\n",
|
|
"\r\n",
|
|
"# Bundle recipe and model spec into a workflow\r\n",
|
|
"poly_wf <- workflow() %>% \r\n",
|
|
" add_recipe(poly_pumpkins_recipe) %>% \r\n",
|
|
" add_model(poly_spec)\r\n",
|
|
"\r\n",
|
|
"\r\n",
|
|
"# Create a model\r\n",
|
|
"poly_wf_fit <- poly_wf %>% \r\n",
|
|
" fit(data = pumpkins_train)\r\n",
|
|
"\r\n",
|
|
"\r\n",
|
|
"# Print learned model coefficients\r\n",
|
|
"poly_wf_fit\r\n",
|
|
"\r\n",
|
|
" "
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "63n_YyRXw3CC"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"#### Valutare le prestazioni del modello\n",
|
|
"\n",
|
|
"👏👏Hai creato un modello polinomiale, ora facciamo delle previsioni sul set di test!\n"
|
|
],
|
|
"metadata": {
|
|
"id": "-LHZtztSxDP0"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Make price predictions on test data\r\n",
|
|
"poly_results <- poly_wf_fit %>% predict(new_data = pumpkins_test) %>% \r\n",
|
|
" bind_cols(pumpkins_test %>% select(c(package, price))) %>% \r\n",
|
|
" relocate(.pred, .after = last_col())\r\n",
|
|
"\r\n",
|
|
"\r\n",
|
|
"# Print the results\r\n",
|
|
"poly_results %>% \r\n",
|
|
" slice_head(n = 10)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "YUFpQ_dKxJGx"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Woo-hoo, valutiamo come il modello ha performato sul test_set usando `yardstick::metrics()`.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "qxdyj86bxNGZ"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"metrics(data = poly_results, truth = price, estimate = .pred)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "8AW5ltkBxXDm"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"🤩🤩 Prestazioni molto migliori.\n",
|
|
"\n",
|
|
"L'`rmse` è diminuito da circa 7 a circa 3, un'indicazione di un errore ridotto tra il prezzo reale e il prezzo previsto. Puoi *liberamente* interpretarlo come se, in media, le previsioni errate sbagliassero di circa 3$. L'`rsq` è aumentato da circa 0,4 a 0,8.\n",
|
|
"\n",
|
|
"Tutti questi parametri indicano che il modello polinomiale funziona decisamente meglio rispetto al modello lineare. Ottimo lavoro!\n",
|
|
"\n",
|
|
"Vediamo se possiamo visualizzarlo!\n"
|
|
],
|
|
"metadata": {
|
|
"id": "6gLHNZDwxYaS"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Bind encoded package column to the results\r\n",
|
|
"poly_results <- poly_results %>% \r\n",
|
|
" bind_cols(package_encode %>% \r\n",
|
|
" rename(package_integer = package)) %>% \r\n",
|
|
" relocate(package_integer, .after = package)\r\n",
|
|
"\r\n",
|
|
"\r\n",
|
|
"# Print new results data frame\r\n",
|
|
"poly_results %>% \r\n",
|
|
" slice_head(n = 5)\r\n",
|
|
"\r\n",
|
|
"\r\n",
|
|
"# Make a scatter plot\r\n",
|
|
"poly_results %>% \r\n",
|
|
" ggplot(mapping = aes(x = package_integer, y = price)) +\r\n",
|
|
" geom_point(size = 1.6) +\r\n",
|
|
" # Overlay a line of best fit\r\n",
|
|
" geom_line(aes(y = .pred), color = \"midnightblue\", size = 1.2) +\r\n",
|
|
" xlab(\"package\")\r\n"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "A83U16frxdF1"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Puoi vedere una linea curva che si adatta meglio ai tuoi dati! 🤩\n",
|
|
"\n",
|
|
"Puoi renderla ancora più fluida passando una formula polinomiale a `geom_smooth` in questo modo:\n"
|
|
],
|
|
"metadata": {
|
|
"id": "4U-7aHOVxlGU"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Make a scatter plot\r\n",
|
|
"poly_results %>% \r\n",
|
|
" ggplot(mapping = aes(x = package_integer, y = price)) +\r\n",
|
|
" geom_point(size = 1.6) +\r\n",
|
|
" # Overlay a line of best fit\r\n",
|
|
" geom_smooth(method = lm, formula = y ~ poly(x, degree = 4), color = \"midnightblue\", size = 1.2, se = FALSE) +\r\n",
|
|
" xlab(\"package\")"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "5vzNT0Uexm-w"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Proprio come una curva fluida!🤩\n",
|
|
"\n",
|
|
"Ecco come fare una nuova previsione:\n"
|
|
],
|
|
"metadata": {
|
|
"id": "v9u-wwyLxq4G"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Make a hypothetical data frame\r\n",
|
|
"hypo_tibble <- tibble(package = \"bushel baskets\")\r\n",
|
|
"\r\n",
|
|
"# Make predictions using linear model\r\n",
|
|
"lm_pred <- lm_wf_fit %>% predict(new_data = hypo_tibble)\r\n",
|
|
"\r\n",
|
|
"# Make predictions using polynomial model\r\n",
|
|
"poly_pred <- poly_wf_fit %>% predict(new_data = hypo_tibble)\r\n",
|
|
"\r\n",
|
|
"# Return predictions in a list\r\n",
|
|
"list(\"linear model prediction\" = lm_pred, \r\n",
|
|
" \"polynomial model prediction\" = poly_pred)\r\n"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "jRPSyfQGxuQv"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"La previsione del `modello polinomiale` ha senso, considerando i grafici a dispersione di `price` e `package`! E, se questo è un modello migliore rispetto al precedente, osservando gli stessi dati, dovrai pianificare un budget per queste zucche più costose!\n",
|
|
"\n",
|
|
"🏆 Ben fatto! Hai creato due modelli di regressione in una sola lezione. Nella sezione finale sulla regressione, imparerai la regressione logistica per determinare le categorie.\n",
|
|
"\n",
|
|
"## **🚀Sfida**\n",
|
|
"\n",
|
|
"Prova diverse variabili in questo notebook per vedere come la correlazione corrisponde alla precisione del modello.\n",
|
|
"\n",
|
|
"## [**Quiz post-lezione**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/14/)\n",
|
|
"\n",
|
|
"## **Revisione & Studio Autonomo**\n",
|
|
"\n",
|
|
"In questa lezione abbiamo imparato la Regressione Lineare. Esistono altri tipi importanti di Regressione. Leggi le tecniche Stepwise, Ridge, Lasso ed Elasticnet. Un buon corso per approfondire è il [corso di Stanford Statistical Learning](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning).\n",
|
|
"\n",
|
|
"Se vuoi imparare di più su come utilizzare il fantastico framework Tidymodels, consulta le seguenti risorse:\n",
|
|
"\n",
|
|
"- Sito web di Tidymodels: [Inizia con Tidymodels](https://www.tidymodels.org/start/)\n",
|
|
"\n",
|
|
"- Max Kuhn e Julia Silge, [*Tidy Modeling with R*](https://www.tmwr.org/)*.*\n",
|
|
"\n",
|
|
"###### **GRAZIE A:**\n",
|
|
"\n",
|
|
"[Allison Horst](https://twitter.com/allison_horst?lang=en) per aver creato le incredibili illustrazioni che rendono R più accogliente e coinvolgente. Trova altre illustrazioni nella sua [galleria](https://www.google.com/url?q=https://github.com/allisonhorst/stats-illustrations&sa=D&source=editors&ust=1626380772530000&usg=AOvVaw3zcfyCizFQZpkSLzxiiQEM).\n"
|
|
],
|
|
"metadata": {
|
|
"id": "8zOLOWqMxzk5"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"\n---\n\n**Disclaimer**: \nQuesto documento è stato tradotto utilizzando il servizio di traduzione automatica [Co-op Translator](https://github.com/Azure/co-op-translator). Sebbene ci impegniamo per garantire l'accuratezza, si prega di notare che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale effettuata da un traduttore umano. Non siamo responsabili per eventuali incomprensioni o interpretazioni errate derivanti dall'uso di questa traduzione.\n"
|
|
]
|
|
}
|
|
]
|
|
} |