La funzionalità Retail verrà rinominata in Vertex AI Search for Retail. Stiamo aggiornando i contenuti in base al nuovo branding.

Questa pagina è stata tradotta dall'API Cloud Translation.

Generare previsioni di vendita dai dati sulla vendita al dettaglio

La pagina fornisce indicazioni per ottenere previsioni da Vertex AI, in base ai dati di vendita al dettaglio esportati in BigQuery. Forniamo diversi blocchi di codice SQL per aiutarti a trasformare i dati sugli eventi degli utenti e sui prodotti di vendita al dettaglio in un formato utilizzabile da Vertex AI. Questi blocchi di codice vengono seguite da procedure per la console Vertex AI per creare un set di dati, addestrare un modello e generare una previsione.

Prima di iniziare

Prima di poter generare previsioni di vendita utilizzando i dati relativi alla vendita al dettaglio, devi:

Carica i dati retail utilizzando Vertex AI Search for Retail. Per maggiori informazioni informazioni, vedi:
Esporta i dati retail da Vertex AI Search for Retail in in BigQuery. Rimangono una tabella dei prodotti e un utente tabella degli eventi in BigQuery, che puoi utilizzare nel seguente le procedure del caso. Per ulteriori informazioni, vedi Esportare i dati in BigQuery.

In alternativa, se i dati sul prodotto e sugli eventi utente sono già presenti BigQuery, nel formato Vertex AI Search for Retail, puoi utilizzare per generare previsioni di vendita a partire dai dati di vendita al dettaglio. In questo caso non caricare i dati retail ed esportarli in BigQuery. Per ulteriori informazioni consulta Schema prodotto e Informazioni sull'utente. eventi.
Assicurati che ti sia stato concesso il ruolo IAM roles/aiplatform.user per fare in modo che puoi eseguire le procedure utilizzando la console Vertex AI.

Creare una tabella delle vendite aggregata

Il codice SQL in questa sezione trasforma la tabella degli eventi utente in una delle vendite. Ciò significa che per ogni prodotto nella tabella degli eventi utente che è venduto almeno una volta, la quantità di vendite del prodotto viene aggregata in un settimanale. Inoltre, il codice SQL esegue le seguenti operazioni:

Per qualsiasi prodotto nella tabella degli eventi utente, se mancano timestamp tra la prima vendita del prodotto nella tabella e l'ultima vendita di qualsiasi prodotto nella tabella, a ciascuno dei timestamp mancanti viene eseguito il backfill con zero vendite. Questo serve a eliminare lacune nella cronologia delle vendite.
Se nella tabella degli eventi utente non è presente almeno un prodotto con almeno 20 timestamp, un prodotto dalla tabella viene scelto in modo casuale e viene eseguito il backfill con un numero di righe sufficiente (ognuna con zero vendite) per raggiungere 20 timestamp. Questo è per soddisfare il requisito di Vertex AI di avere almeno 20 timestamp durante l'addestramento di un modello.

Per creare una tabella delle vendite aggregate:

Sostituisci le variabili nel seguente codice di esempio SQL come segue:

starting_day_of_week. Il giorno in cui inizia la settimana. Valori validi: MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY.
rdm_user_event_table. Gli ID progetto, set di dati e tabella dell'utente che hai esportato in BigQuery. Il formato è project_id.dataset_id.table_id.
rdm_product_table. Gli ID progetto, set di dati e tabella della tabella dei prodotti che hai esportato in BigQuery. Il formato è project_id.dataset_id.table_id.
aggregated_sales_table. Gli ID progetto, set di dati e tabella in BigQuery per la nuova tabella aggregata delle vendite. Usa lo stesso come tabelle di prodotto ed eventi utente. Utilizza l'ID di un modello esistente del set di dati. Specifica un ID tabella, ma non utilizzare l'ID di una tabella esistente a meno che tu non voglia sovrascriverlo. Il formato è project_id.dataset_id.table_id.

Esempio di codice SQL

  DECLARE max_date DATE;

  SET max_date = (SELECT LAST_DAY(DATETIME(max(event_time)),
  WEEK(STARTING_DAY_OF_WEEK)) FROM `RDM_USER_EVENT_TABLE`);

  CREATE OR REPLACE TABLE `AGGREGATED_SALES_TABLE` AS
  WITH flatten_sku AS
  (
    SELECT * EXCEPT(quantity, product), COALESCE(quantity, 1) as quantity,
    product.id as sku FROM
    (
      SELECT * EXCEPT(product_details),
      FROM `RDM_USER_EVENT_TABLE`,
      UNNEST(product_details) AS product_detail
    )
    WHERE product IS NOT NULL
  ),

  aggregate_by_type as
  (
      SELECT event_type, sum(quantity) as quantity, sku,
      LAST_DAY(DATETIME(event_time), WEEK(STARTING_DAY_OF_WEEK)) as
      last_day_of_week
      from flatten_sku group by event_type, sku, last_day_of_week
  ),

  sales_table as
  (
      SELECT quantity, sku, last_day_of_week FROM aggregate_by_type where
      event_type = 'purchase-complete'
  ),

  sales_table_with_known_products as
  (
      SELECT * EXCEPT (product_table_sku) FROM
      (
          SELECT s.*, p.id as product_table_sku FROM sales_table as s LEFT JOIN
          `RDM_PRODUCT_TABLE` as p
          ON s.sku = p.id
      )
      WHERE product_table_sku is NOT NULL
  ),

  fill_gap as
  (
      SELECT sku, sale_date as last_day_of_week, 0 as quantity
      FROM
      (
          SELECT sku, GENERATE_DATE_ARRAY(min_date, max_date, INTERVAL 7 DAY)
          date_range FROM
          (
              SELECT sku , MIN(last_day_of_week) as min_date FROM
              sales_table_with_known_products GROUP BY sku
          )
      ),
      UNNEST(date_range) sale_date
  ),

  sales_table_backfill as
  (
      SELECT fill_gap.sku, fill_gap.last_day_of_week, coalesce(original.quantity,
      fill_gap.quantity) as quantity
      FROM
      fill_gap LEFT JOIN sales_table_with_known_products original
      ON fill_gap.sku = original.sku and fill_gap.last_day_of_week =
      original.last_day_of_week
  ),

  one_sku_extend_history as
  (
      SELECT sku, GENERATE_DATE_ARRAY(IF(min_date < DATE_SUB(max_date, INTERVAL
      140 DAY), min_date, DATE_SUB(max_date, INTERVAL 140 DAY)), max_date,
      INTERVAL 7 DAY) date_range FROM
      (
          SELECT sku , MIN(last_day_of_week) as min_date FROM sales_table_backfill
          GROUP BY sku LIMIT 1
      )
  ),

  one_sku_extend_history2 as
  (
      SELECT backfill.sku, backfill.sale_date as last_day_of_week,
      coalesce(original.quantity, backfill.sale_quantity) as quantity
      FROM
      (
          SELECT sku, sale_date, 0 as sale_quantity
          FROM one_sku_extend_history,
              UNNEST(date_range) sale_date
      ) backfill
      LEFT JOIN sales_table_backfill original
      ON backfill.sku = original.sku and backfill.sale_date =
      original.last_day_of_week
  ),

  sales_table_extend_history as
  (
      SELECT quantity, sku, last_day_of_week
      FROM sales_table_backfill
      WHERE sku not in
      (select sku from one_sku_extend_history)
      UNION ALL
      SELECT quantity, sku, last_day_of_week
      FROM
      one_sku_extend_history2
  ),

  other_event_table as
  (
      SELECT sku, last_day_of_week,
      SUM(category_page_view_quantity) as category_page_view_quantity,
      SUM(search_quantity) as search_quantity,
      SUM(detail_page_view_quantity) as detail_page_view_quantity,
      SUM(add_to_cart_quantity) as add_to_cart_quantity
      FROM
      (
          SELECT sku, last_day_of_week,
          CASE
              WHEN event_type = 'category-page-view' THEN quantity
          END as category_page_view_quantity,
          CASE
              WHEN event_type = 'search' THEN quantity
          END as search_quantity,
          CASE
              WHEN event_type = 'detail-page-view' THEN quantity
          END as detail_page_view_quantity,
          CASE
              WHEN event_type = 'add-to-cart' THEN quantity
          END as add_to_cart_quantity,
          FROM aggregate_by_type WHERE event_type != 'purchase-complete'
      ) GROUP BY sku, last_day_of_week
  )

  SELECT t1.*, t2.category_page_view_quantity, t2.search_quantity,
  t2.detail_page_view_quantity, t2.add_to_cart_quantity
  FROM sales_table_extend_history as t1 left join other_event_table as t2
  ON t1.sku = t2.sku AND t1.last_day_of_week = t2.last_day_of_week

Copia l'esempio di codice SQL.
Apri la pagina BigQuery nella console Google Cloud.

Vai alla pagina di BigQuery
Se non è già selezionato, seleziona il progetto che contiene il prodotto. ed eventi utente.
Nel riquadro Editor, incolla l'esempio di codice SQL.
Fai clic su Esegui e attendi eseguire la query.

La nuova tabella aggregata delle vendite è scritta nella posizione in BigQuery che imposti utilizzando aggregated_sales_table .

Elabora la tabella dei prodotti

Il codice SQL in questa sezione agisce sulla tabella dei prodotti che hai esportato in BigQuery, rimuovendo i campi ripetuti e struct e annullando il nidificazione del campo price_info nei relativi campi secondari. Obbligatorio perché Vertex AI non accetta elenchi o strutture nidificate. Il risultato è nella tabella dei prodotti elaborati.

Per elaborare la tabella prodotti:

Sostituisci le variabili nel seguente codice di esempio SQL come segue:
- rdm_product_table. Gli ID progetto, set di dati e tabella del prodotto che hai esportato in BigQuery. Il formato è project_id.dataset_id.table_id.
- processed_product_table. Gli ID progetto, set di dati e tabella in BigQuery per la nuova tabella dei prodotti elaborata. Usa lo stesso come tabelle di prodotto ed eventi utente. Utilizza l'ID di un modello esistente del set di dati. Specifica un ID tabella, ma non utilizzare l'ID di una tabella esistente a meno che tu non voglia sovrascriverlo. Il formato è project_id.dataset_id.table_id.
```
CREATE OR REPLACE TABLE `PROCESSED_PRODUCT_TABLE` AS
SELECT * EXCEPT (id, attributes, price_info, rating, expire_time,
available_time, fulfillment_info, images, audience, color_info, promotions,
publish_time, retrievable_fields, categories, brands, conditions, sizes,
collection_member_ids, tags, materials, patterns),
id as sku,
price_info.price as price_info_price,
price_info.currency_code as price_info_currency_code,
price_info.cost as price_info_cost,
FROM `RDM_PRODUCT_TABLE`
```
Copia l'esempio di codice SQL.
Apri la pagina BigQuery nella console Google Cloud.

Vai alla pagina di BigQuery
Se non è già selezionato, seleziona il progetto che contiene il prodotto. ed eventi utente.
Nel riquadro Editor, incolla l'esempio di codice SQL.
Fai clic su Esegui e attendi eseguire la query.

La nuova tabella dei prodotti elaborati viene scritta nella posizione in BigQuery che hai impostato utilizzando la variabile processed_product_table.

Crea una tabella di previsione degli eventi

Il codice SQL in questa sezione estrae ogni SKU venduto almeno una volta in nella tabella degli eventi utente. Il codice crea una tabella di previsione degli eventi contenente tutti gli SKU estratti in tutti i timestamp futuri. Il futuro sono un array di timestamp settimanali continui, a partire dal timestamp finale settimana nella tabella degli eventi utente + 1 settimana fino all'ultima settimana dell'utente tabella degli eventi + future_length settimane. Imposta il valore future_length su il numero di settimane future che vuoi prevedere con il modello. Ogni riga nella tabella di previsione degli eventi può essere identificata in modo univoco da uno SKU e da un timestamp.

Per creare una tabella di previsione degli eventi:

Sostituisci le variabili nel seguente codice di esempio SQL come segue:

starting_day_of_week. Il giorno in cui inizia la settimana. Valori validi: MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY.
rdm_user_event_table. Gli ID progetto, set di dati e tabella dell'utente che hai esportato in BigQuery. Il formato è project_id.dataset_id.table_id.
events_prediction_table. Gli ID progetto, set di dati e tabella in BigQuery per la nuova tabella di previsione degli eventi. Usa lo stesso come tabelle di prodotto ed eventi utente. Utilizza l'ID di un set di dati esistente. Specifica un ID tabella, ma non utilizzare l'ID di una tabella esistente se non vuoi sovrascriverlo. Il formato è project_id.dataset_id.table_id.
rdm_product_table. Gli ID progetto, set di dati e tabella per la tabella dei prodotti che hai esportato in BigQuery. Il formato è project_id.dataset_id.table_id.
future_length. Il numero di settimane future dopo l'ultima settimana nella tabella degli eventi utente, che il modello prevede.

Esempio di codice SQL

  DECLARE max_date DATE;

  SET max_date = (SELECT LAST_DAY(DATETIME(max(event_time)),
  WEEK(STARTING_DAY_OF_WEEK)) FROM `RDM_USER_EVENT_TABLE`);

  CREATE OR REPLACE TABLE `EVENTS_PREDICTION_TABLE` AS
  WITH purchase_events as
  (
  SELECT * EXCEPT (product_details, product),
  order_item.product.id as sku
  FROM `RDM_USER_EVENT_TABLE`,
  UNNEST(product_details) as order_item
  WHERE event_type = 'purchase-complete'
  ),

  known_products_in_purchase_events as
  (
      SELECT sku FROM
      (
          SELECT s.sku, p.id as product_table_sku
          FROM (SELECT DISTINCT(sku) FROM purchase_events) as s
          LEFT JOIN `RDM_PRODUCT_TABLE` as p
          ON s.sku = p.id
      )
      WHERE product_table_sku is NOT NULL
  ),

  sales_table_future as
  (
      SELECT sku, future_date as last_day_of_week, NULL as quantity FROM
      (
          SELECT sku, GENERATE_DATE_ARRAY(DATE_ADD(max_date, INTERVAL 1 WEEK),
          DATE_ADD(max_date, INTERVAL FUTURE_LENGTH WEEK), INTERVAL 1
          WEEK)
          date_range
          FROM known_products_in_purchase_events
      ), UNNEST(date_range) future_date
  )
  SELECT * FROM sales_table_future

Copia l'esempio di codice SQL.
Apri la pagina BigQuery nella console Google Cloud.

Vai alla pagina di BigQuery
Se non è già selezionato, seleziona il progetto che contiene il prodotto. ed eventi utente.
Nel riquadro Editor, incolla l'esempio di codice SQL.
Fai clic su Esegui e attendi il completamento dell'esecuzione della query.

La nuova tabella di previsione degli eventi è scritta nella posizione in BigQuery che imposti utilizzando events_prediction_table .

crea una tabella di addestramento Vertex AI

Il codice SQL in questa sezione unisce la tabella delle vendite aggregate alla tabella dei prodotti elaborati. Il risultato è una tabella di addestramento Vertex AI, che utilizzati da Vertex AI per l'addestramento del modello.

Per creare una tabella di addestramento Vertex AI:

Sostituisci le variabili nel seguente codice di esempio SQL come segue:
- vertex_ai_training_table. Gli ID progetto, set di dati e tabella in BigQuery per la nuova tabella di addestramento Vertex AI. Utilizza lo stesso ID progetto delle tabelle degli eventi utente e dei prodotti. Utilizza l'ID di un un set di dati esistente. Specifica un ID tabella, ma non utilizzare l'ID di un a meno che tu non voglia sovrascriverla. Il formato è project_id.dataset_id.table_id.
- aggregated_sales_table. Gli ID progetto, set di dati e tabella in BigQuery della tabella delle vendite aggregate creata Crea una tabella delle vendite aggregata.
- processed_product_table. Gli ID progetto, set di dati e tabella in BigQuery per la tabella dei prodotti elaborata che hai creato in Elaborare la tabella dei prodotti.
```
CREATE OR REPLACE TABLE `VERTEX_AI_TRAINING_TABLE` AS
SELECT t1.*, t2.* EXCEPT(sku) FROM `AGGREGATED_SALES_TABLE` AS t1
LEFT
JOIN `PROCESSED_PRODUCT_TABLE` AS t2 ON t1.sku = t2.sku
```
Copia l'esempio di codice SQL.
Apri la pagina BigQuery nella console Google Cloud.

Vai alla pagina BigQuery
Se non è già selezionato, seleziona il progetto che contiene le tabelle dei prodotti e degli eventi utente.
Nel riquadro Editor, incolla l'esempio di codice SQL.
Fai clic su Esegui e attendi il completamento dell'esecuzione della query.

La nuova tabella di addestramento Vertex AI è scritta nella posizione in BigQuery che imposti utilizzando vertex_ai_training_table .

Crea una tabella di previsione di Vertex AI

Il codice SQL in questa sezione aggiunge la tabella di previsione degli eventi al una tabella aggregata delle vendite e la unisce alla tabella dei prodotti elaborata. La il risultato è la tabella di previsione di Vertex AI, utilizzata per creare un previsione.

Per creare una tabella di previsione di Vertex AI:

Sostituisci le variabili nel seguente codice di esempio SQL come segue:
- vertex_ai_prediction_table. Gli ID progetto, set di dati e tabella in BigQuery per la nuova tabella di previsione di Vertex AI. Utilizza le funzionalità di lo stesso ID progetto e ID set di dati che hai utilizzato per il prodotto e l'utente e tabelle di eventi. Non utilizzare l'ID di una tabella esistente a meno che tu non voglia sovrascriverla. Il formato è project_id.dataset_id.table_id.
- aggregated_sales_table. Gli ID progetto, set di dati e tabella in BigQuery per la tabella delle vendite aggregate, che hai creato Crea una tabella delle vendite aggregata.
- processed_product_table. Gli ID progetto, set di dati e tabella in BigQuery per la tabella dei prodotti elaborata che hai creato in Elaborare la tabella dei prodotti.
- events_prediction_table. Gli ID progetto, set di dati e tabella in BigQuery per la tabella di previsione degli eventi che hai creato. in Creare una tabella di previsione degli eventi.
```
CREATE OR REPLACE TABLE `VERTEX_AI_PREDICTION_TABLE` AS
WITH append_predict_to_history AS (
  SELECT add_to_cart_quantity, category_page_view_quantity,
  detail_page_view_quantity, last_day_of_week, quantity, search_quantity, sku
  FROM `AGGREGATED_SALES_TABLE` UNION ALL SELECT NULL AS
  add_to_cart_quantity, NULL AS category_page_view_quantity, NULL AS
  detail_page_view_quantity, last_day_of_week, NULL AS quantity, NULL AS
  search_quantity, sku FROM `EVENTS_PREDICTION_TABLE`
)
SELECT t1.*, t2.* EXCEPT(sku) FROM append_predict_to_history AS t1 LEFT JOIN
`PROCESSED_PRODUCT_TABLE` AS t2 ON t1.sku = t2.sku
```
Copia l'esempio di codice SQL.
Apri la pagina BigQuery nella console Google Cloud.

Vai alla pagina di BigQuery
Se non è già selezionato, seleziona il progetto che contiene il prodotto. ed eventi utente.
Nel riquadro Editor, incolla l'esempio di codice SQL.
Fai clic su Esegui e attendi eseguire la query.

La nuova tabella di previsione di Vertex AI viene scritta nella posizione in BigQuery che hai impostato utilizzando la variabile vertex_ai_prediction_table.

crea un set di dati Vertex AI

Questa sezione mostra come creare un set di dati Vertex AI che puoi utilizzare per addestrare un modello di previsione. Per ulteriori informazioni, consulta Creare un set di dati per di addestramento dei modelli di previsione documentazione di Vertex AI.

Per creare un set di dati Vertex AI:

Nella console Google Cloud, nella sezione Vertex AI, vai al Set di dati.

Vai alla pagina Set di dati
Fai clic su Crea per aprire la pagina Crea set di dati.
Nel campo Nome set di dati, inserisci un nome per il nuovo set di dati.
Seleziona la scheda Tabulare.
Seleziona l'obiettivo Previsione.
Nell'elenco Regione, seleziona la regione utilizzata per creare un set di dati per esportare i dati di vendita al dettaglio in BigQuery. Se hai selezionato us quando hai creato il set di dati BigQuery, puoi selezionare qualsiasi regione degli Stati Uniti. Analogamente, se hai selezionato eu quando hai creato il set di dati BigQuery, puoi selezionare qualsiasi regione dell'Unione europea. Per ulteriori informazioni, vedi Esportare i dati in BigQuery.
Fai clic su Crea per creare il set di dati vuoto e passa all'Origine. .
Seleziona Seleziona una tabella o una visualizzazione da BigQuery.
In Seleziona una tabella o una vista da BigQuery, inserisci ID progetto, set di dati e tabella per la tabella di addestramento di Vertex AI creato in Creare un addestramento Vertex AI . Il formato è project_id.dataset_id.table_id.
Fai clic su Continua.

L'origine dati è associata al set di dati.
Nella scheda Analizza, seleziona sku nell'elenco Colonna identificatore serie e last_day_of_week nell'elenco Colonna timestamp.
Fai clic su Addestra nuovo modello per passare alla pagina Addestra nuovo modello. Per istruzioni per addestrare il modello, consulta Addestrare un modello di previsione.

Addestra un modello di previsione

Questa sezione mostra come addestrare un modello di previsione utilizzando il set di dati che creato in Creare un set di dati Vertex AI. Per ulteriori informazioni, consulta Addestrare un modello di previsione in la documentazione di Vertex AI.

Prima di iniziare

Prima di poter addestrare un modello di previsione, devi creare un set di dati Vertex AI.

Addestra un modello

Nella pagina Metodo di addestramento, seleziona il metodo di addestramento del modello. Per per informazioni sui metodi di addestramento. Consulta Addestrare un modello nella documentazione di Vertex AI.

Fai clic su Continua.
Nella pagina Dettagli modello, configura come segue:
1. Seleziona Addestra nuovo modello, se non è già selezionato.
2. Inserisci un nome per il nuovo modello.
3. Seleziona quantity (INTEGER) dall'elenco Colonna target.
4. Seleziona Settimanale dall'elenco Granularità dei dati.
5. Inserisci una finestra di contesto e un orizzonte di previsione.
  
  L'orizzonte di previsione determina per quanto lontano nel futuro il modello deve fare la previsione del valore target per ogni riga di dati di previsione. L'orizzonte di previsione è specificato in unità di granularità dei dati.
  
  La finestra di contesto consente di impostare quanto indietro può apparire il modello durante l'addestramento (e per le previsioni). In altre parole, per ogni punto dati di addestramento, finestra contestuale determina quanto indietro nel tempo il modello cerca pattern. Se non specifichi una finestra di contesto, il valore predefinito sarà per Orizzonte di previsione. La finestra di contesto è specificata in unità di Granularità dei dati.
  
  Per ulteriori informazioni, consulta Considerazioni per l'impostazione della finestra di contesto e dell'orizzonte di previsione nella documentazione di Vertex AI.
6. Fai clic su Continua.
Nella pagina Opzioni di addestramento, configura come segue. Tieni presente che quando La freccia menu a discesa è grigia oppure se non sono presenti frecce freccia menu a discesa, il valore non può essere modificato.
1. Seleziona un valore Trasformazione per le colonne in Nome colonna elenco come segue:
  - Se il valore Tipo di BigQuery è In virgola mobile, Numero intero o Numerico, imposta il valore Trasformazione su Numerico.
  - Se il valore Tipo di BigQuery è Stringa oppure Booleano, imposta il valore Transformation su Categorical.
  - Se il valore Tipo di BigQuery è Data, imposta il valore Il valore di Transformation in Timestamp.
2. Seleziona un valore Tipo di funzionalità per le colonne in Nome colonna. elenco come segue:
  - Per add_to_cart_quantity, category_page_view_quantity, detail_page_view_quantity e search_quantity, Imposta il valore di Tipo di caratteristica su Covariata.
  - Delle colonne rimanenti, per quelle che possono essere modificate, imposta il valore Da Tipo di elemento su Attributo.
3. Seleziona un valore Disponibile al momento della previsione per le colonne nella Colonna di testo come segue:
  - Per add_to_cart_quantity, category_page_view_quantity, detail_page_view_quantity e search_quantity, Imposta il valore Disponibilità al momento della previsione su Non disponibile.
  - Delle colonne rimanenti, per quelle che possono essere modificate, imposta il valore Il valore Tipo di caratteristica su Disponibile.
4. Fai clic su Continua.
Nella pagina Compute e prezzi, inserisci il numero massimo di ore in cui per l'addestramento del modello. Questa impostazione ti aiuta a limitare l'addestramento costi aggiuntivi. Il tempo effettivo trascorso può essere maggiore di questo valore perché ci sono altre operazioni legate alla creazione di un nuovo modello. Per informazioni sul tempo necessario per addestrare modelli di alta qualità, consulta Addestrare un modello nella documentazione di Vertex AI.
Fai clic su Inizia addestramento.

L'addestramento del modello può richiedere molte ore, a seconda delle dimensioni e della complessità del i dati e il budget per l'addestramento, se ne hai specificato uno. Puoi chiudere per tornare indietro in un secondo momento. Riceverai un'email al termine dell'addestramento del modello. Se vuoi monitorare l'avanzamento del modello consulta Monitorare l'avanzamento della formazione.

Monitora i progressi dell'addestramento

Nella console Google Cloud, nella sezione Vertex AI, vai al Pagina di addestramento.

Vai alla pagina Formazione
Se non è già selezionata, seleziona la scheda Pipeline di addestramento. Il modello che stai addestrando dovrebbe essere nell'elenco. L'addestramento termina quando lo stato cambia da Addestramento a Terminato.

Creare una previsione

Questa pagina mostra come creare una previsione utilizzando il modello addestrato in Addestra un modello di previsione.

Prima di iniziare

Prima di poter creare una previsione, devi addestrare un modello di previsione.

Effettua una richiesta di previsione batch al tuo modello

Nella console Google Cloud, nella sezione Vertex AI, vai alla pagina Predizioni batch.

Vai alla pagina Previsioni batch
Fai clic su Crea per aprire la finestra Nuova previsione batch e completare la seguenti passaggi:
1. Inserisci un nome per la previsione batch.
2. Nell'elenco Nome modello, seleziona il modello che hai addestrato in Addestra un modello modello di previsione.
3. Nell'elenco Versione, seleziona la versione del modello.
4. In Seleziona origine:
  1. Seleziona Tabella BigQuery se non è già selezionata.
  2. Inserisci gli ID progetto, set di dati e tabella in BigQuery per la tabella di previsione di Vertex AI che hai creato in Creare una tabella di previsione di Vertex AI. Il formato è project_id.dataset_id.table_id.
5. In Output di previsione batch:
  1. Nell'elenco Formato di output, seleziona Tabella BigQuery.
  2. Inserisci gli ID progetto e set di dati in BigQuery per il batch e la tabella di output della previsione che stai creando. Utilizza lo stesso ID progetto e l'ID del set di dati utilizzato per le tabelle dei prodotti e degli eventi utente. Il formato è project_id.dataset_id.
6. Fai clic su Crea. Viene visualizzata la pagina Previsioni batch.
  
  La previsione termina quando lo stato passa da In attesa a Terminato. Riceverai un'email anche quando la previsione batch completato. L'output della richiesta di previsione batch viene restituito nel nel progetto BigQuery che hai specificato. La il nome della nuova tabella di output è "predictions_" in aggiunta alla timestamp di inizio del job di previsione. Per saperne di più sul recupero e sull'interpretazione dei risultati di previsione, consulta Recupero dei risultati di previsione per batch e Interpretazione dei risultati di previsione nella documentazione di Vertex AI.