Optimiser le prix des produits de détail

1. Introduction

Dernière mise à jour : 15/09/2021

Les données nécessaires pour générer des insights et optimiser les prix sont disparates par nature (systèmes différents, réalités locales différentes, etc.). Il est donc essentiel de développer une table CDM bien structurée, standardisée et propre. Cela inclut les attributs clés pour l'optimisation des prix, comme les transactions, les produits, les prix et les clients. Dans ce document, nous vous expliquons les étapes décrites ci-dessous. Vous pourrez ainsi commencer rapidement à analyser vos tarifs, puis étendre et personnaliser cette analyse selon vos besoins. Le schéma suivant présente les étapes décrites dans ce document.

dd8545e0c9156b13.png

  1. Évaluez les sources de données : vous devez d'abord obtenir un inventaire des sources de données qui seront utilisées pour créer le CDM. À cette étape, Dataprep est également utilisé pour explorer les données d'entrée et identifier les problèmes qu'elles contiennent. Par exemple, des valeurs manquantes ou non concordantes, des conventions de nommage incohérentes, des doublons, des problèmes d'intégrité des données, des valeurs aberrantes, etc.
  2. Normaliser les données : les problèmes précédemment identifiés sont ensuite résolus pour garantir l'exactitude, l'intégrité, la cohérence et l'exhaustivité des données. Ce processus peut impliquer diverses transformations dans Dataprep, telles que la mise en forme des dates, la standardisation des valeurs, la conversion des unités, le filtrage des champs et valeurs inutiles, ainsi que la division, la fusion ou la déduplication des données sources.
  3. Unification dans une seule structure : l'étape suivante du pipeline joint chaque source de données dans une seule table large dans BigQuery contenant tous les attributs au niveau de granularité le plus fin. Cette structure dénormalisée permet d'exécuter des requêtes analytiques efficaces qui ne nécessitent pas de jointures.
  4. Fournir des analyses et du ML/de l'IA : une fois les données nettoyées et mises en forme pour l'analyse, les analystes peuvent explorer les données historiques pour comprendre l'impact des modifications de prix précédentes. De plus, BigQuery ML peut être utilisé pour créer des modèles prédictifs qui estiment les ventes futures. Les résultats de ces modèles peuvent être intégrés à des tableaux de bord dans Looker pour créer des scénarios "et si". Les utilisateurs professionnels peuvent ainsi analyser l'impact de certaines modifications de prix sur les ventes.

Le diagramme suivant montre les composants Google Cloud utilisés pour créer le pipeline d'analyse de l'optimisation des prix.

e5d74e43074eedf4.png

Objectifs de l'atelier

Nous allons vous montrer comment concevoir un entrepôt de données d'optimisation des prix, automatiser la préparation des données au fil du temps, utiliser le machine learning pour prédire l'impact des modifications apportées aux prix des produits et développer des rapports pour fournir des insights exploitables à votre équipe.

Points abordés

  • Découvrez comment connecter Dataprep à des sources de données pour l'analyse des prix, qui peuvent être stockées dans des bases de données relationnelles, des fichiers plats, Google Sheets et d'autres applications compatibles.
  • Découvrez comment créer un flux Dataprep pour créer une table CDM dans votre entrepôt de données BigQuery.
  • Découvrez comment utiliser BigQuery ML pour prédire les revenus futurs.
  • Découvrez comment créer des rapports dans Looker pour analyser l'historique des prix et les tendances des ventes, et comprendre l'impact des futures modifications de prix.

Prérequis

2. Créer le CDM dans BigQuery

Dans cette section, vous allez créer le modèle de données commun (CDM), qui fournit une vue consolidée des informations dont vous avez besoin pour analyser et suggérer des modifications de prix.

  1. Ouvrez la console BigQuery.
  2. Sélectionnez le projet que vous souhaitez utiliser pour tester ce modèle de référence.
  3. Utilisez un ensemble de données existant ou créez un ensemble de données BigQuery. Nommez l'ensemble de données Pricing_CDM.
  4. Créez la table :
create table `CDM_Pricing`
(
  Fiscal_Date DATETIME,
  Product_ID STRING,
  Client_ID INT64,
  Customer_Hierarchy STRING,
  Division STRING,
  Market STRING,
  Channel STRING,
  Customer_code INT64,
  Customer_Long_Description STRING,
  Key_Account_Manager INT64,
  Key_Account_Manager_Description STRING,
  Structure STRING,
  Invoiced_quantity_in_Pieces FLOAT64,
  Gross_Sales FLOAT64,
  Trade_Budget_Costs FLOAT64,
  Cash_Discounts_and_other_Sales_Deductions INT64,
  Net_Sales FLOAT64,
  Variable_Production_Costs_STD FLOAT64,
  Fixed_Production_Costs_STD FLOAT64,
  Other_Cost_of_Sales INT64,
  Standard_Gross_Margin FLOAT64,
  Transportation_STD FLOAT64,
  Warehouse_STD FLOAT64,
  Gross_Margin_After_Logistics FLOAT64,
  List_Price_Converged FLOAT64
);

3. Évaluer les sources de données

Dans ce tutoriel, vous allez utiliser des exemples de sources de données stockées dans Google Sheets et BigQuery.

  • La feuille de calcul Google Sheets transactions, qui contient une ligne pour chaque transaction. Il contient des informations telles que la quantité de chaque produit vendu, le total des ventes brutes et les coûts associés.
  • La feuille de calcul Google Sheets product pricing (tarification des produits) qui contient le prix de chaque produit pour un client donné et pour chaque mois.
  • Table BigQuery "company_descriptions" contenant des informations sur les clients individuels.

Vous pouvez créer cette table BigQuery company_descriptions à l'aide de l'instruction suivante :

create table `Company_Descriptions`
(
 Customer_ID INT64,
 Customer_Long_Description STRING
);
insert into `Company_Descriptions` values (15458, 'ENELTEN');
insert into `Company_Descriptions` values (16080, 'NEW DEVICES CORP.');
insert into `Company_Descriptions` values (19913, 'ENELTENGAS');
insert into `Company_Descriptions` values (30108, 'CARTOON NT');
insert into `Company_Descriptions` values (32492, 'Thomas Ed Automobiles');

4. Créer le flux

Dans cette étape, vous allez importer un exemple de flux Dataprep, que vous utiliserez pour transformer et unifier les exemples d'ensembles de données listés dans la section précédente. Un flux représente un pipeline ou un objet qui rassemble des ensembles de données et des recettes, qui sont utilisés pour les transformer et les joindre.

  1. Téléchargez le package de flux Pricing Optimization Pattern depuis GitHub, mais ne le décompressez pas. Ce fichier contient le flux du modèle de conception d'optimisation des prix utilisé pour transformer les exemples de données.
  2. Dans Dataprep, cliquez sur l'icône Flux dans la barre de navigation de gauche. Dans la vue "Flux", sélectionnez Importer dans le menu contextuel. Une fois le flux importé, vous pouvez le sélectionner pour l'afficher et le modifier.

dd5213e4cf1e313f.png

  1. Sur la gauche du flux, le prix du produit et chacun des trois fichiers Google Sheets de transactions doivent être associés en tant qu'ensembles de données. Pour ce faire, effectuez un clic droit sur les objets de l'ensemble de données Google Sheets, puis sélectionnez Remplacer. Cliquez ensuite sur le lien Import Datasets (Importer des ensembles de données). Cliquez sur l'icône en forme de crayon "Modifier le chemin", comme indiqué dans le schéma suivant.

7e4af3e82955343f.png

Remplacez la valeur actuelle par le lien pointant vers les feuilles de calcul Google Sheets Transactions et Prix des produits .

Lorsque Google Sheets contient plusieurs onglets, vous pouvez sélectionner celui que vous souhaitez utiliser dans le menu. Cliquez sur Modifier, sélectionnez les onglets que vous souhaitez utiliser comme source de données, puis cliquez sur Enregistrer et sur Importer et ajouter au flux. De retour dans la fenêtre modale, cliquez sur Remplacer. Dans ce flux, chaque feuille est représentée sous la forme de son propre ensemble de données pour illustrer l'union de sources disparates dans une recette ultérieure.

799bce35e0a60e87.png

  1. Définir les tables de sortie BigQuery :

Dans cette étape, vous allez associer l'emplacement de la table de sortie CDM_Pricing BigQuery à charger chaque fois que vous exécutez le job Dataoprep.

Dans la vue Flux, cliquez sur l'icône "Sortie du mappage de schéma". Dans le panneau "Détails", cliquez sur l'onglet "Destinations". À partir de là, modifiez à la fois la sortie des destinations manuelles utilisée pour les tests et celle des destinations programmées utilisée lorsque vous souhaitez automatiser l'ensemble de votre flux. Pour ce faire, procédez comme suit :

  1. Modifiez les destinations manuelles. Dans le panneau "Détails", sous la section "Destinations manuelles", cliquez sur le bouton "Modifier". Sur la page Paramètres de publication, sous "Actions de publication", si une action de publication existe déjà, modifiez-la. Sinon, cliquez sur le bouton "Ajouter une action". À partir de là, accédez aux ensembles de données BigQuery, puis à l'ensemble de données Pricing_CDM que vous avez créé à l'étape précédente, et sélectionnez la table CDM_Pricing. Vérifiez que l'option Ajouter à cette table à chaque exécution est cochée, puis cliquez sur Ajouter et sur Enregistrer les paramètres.
  2. Modifier les "Destinations programmées"

Dans le panneau "Détails", sous la section "Destinations programmées", cliquez sur Modifier.

Les paramètres sont hérités des destinations manuelles et vous n'avez pas besoin de les modifier. Cliquez sur "Enregistrer les paramètres".

5. Standardiser les données

Le flux fourni unifie, met en forme et nettoie les données de transaction, puis joint le résultat aux descriptions des entreprises et aux données de tarification agrégées pour la création de rapports. Vous allez maintenant découvrir les composants du flux, qui sont visibles dans l'image ci-dessous.

a033de41c68acc8b.png

6. Explorer la recette "Données transactionnelles"

Vous allez d'abord découvrir ce qui se passe dans la recette de données transactionnelles, qui est utilisée pour préparer les données de transactions. Cliquez sur l'objet "Données de transaction" dans la vue Flux. Dans le panneau "Détails", cliquez sur le bouton "Modifier la combinaison".

La page "Transformer" s'ouvre avec la recette présentée dans le panneau "Détails". La recette contient toutes les étapes de transformation appliquées aux données. Vous pouvez parcourir la recette en cliquant entre chaque étape pour voir l'état des données à cette position spécifique de la recette.

Vous pouvez également cliquer sur le menu "Plus" de chaque étape de la recette, puis sélectionner "Accéder à la sélection" ou "Modifier" pour découvrir comment fonctionne la transformation.

  1. Union des transactions : la première étape de la recette de données transactionnelles consiste à unir les transactions stockées dans différentes feuilles représentant chaque mois.
  2. Standardiser les descriptions des clients : l'étape suivante de la recette consiste à standardiser les descriptions des clients. Cela signifie que les noms de clients peuvent être similaires, avec de légères différences. Nous souhaitons les normaliser en un seul nom. La recette présente deux approches possibles. Tout d'abord, il utilise l'algorithme de standardisation, qui peut être configuré avec différentes options de standardisation telles que "Chaînes similaires" (les valeurs avec des caractères en commun sont regroupées) ou "Prononciation" (les valeurs qui se prononcent de la même manière sont regroupées). Vous pouvez également rechercher la description de l'entreprise dans la table BigQuery référencée ci-dessus à l'aide de l'ID de l'entreprise.

Vous pouvez parcourir la recette pour découvrir les différentes techniques appliquées pour nettoyer et mettre en forme les données : supprimer des lignes, mettre en forme en fonction de modèles, enrichir les données avec des recherches, traiter les valeurs manquantes ou remplacer les caractères indésirables.

7. Explorer la recette de données sur les prix des produits

Vous pouvez ensuite explorer ce qui se passe dans la recette de données sur les tarifs des produits, qui joint les données de transactions préparées aux données tarifaires agrégées.

Cliquez sur le MODÈLE DE CONCEPTION D'OPTIMISATION DES PRIX en haut de la page pour fermer la page "Transformateur" et revenir à la vue du flux. Cliquez ensuite sur l'objet de données "Product Pricing Data" (Données de tarification des produits), puis modifiez la recette.

  1. Inverser les colonnes de prix mensuels : cliquez sur la recette entre les étapes 2 et 3 pour voir à quoi ressemblent les données avant l'étape "Inverser". Vous remarquerez que les données contiennent la valeur de la transaction dans une colonne distincte pour chaque mois : "Jan", "Fév" et "Mar". Ce format ne convient pas pour appliquer un calcul d'agrégation (c'est-à-dire la somme ou la moyenne des transactions) en SQL. Les données doivent être "dépivotées" afin que chaque colonne devienne une ligne dans la table BigQuery. La recette utilise la fonction unpivot pour transformer les trois colonnes en une seule ligne pour chaque mois. Il est ainsi plus facile d'appliquer des calculs de groupe par la suite.
  2. Calculer la valeur moyenne des transactions par client, produit et date : nous voulons calculer la valeur moyenne des transactions pour chaque client, produit et date. Nous pouvons utiliser la fonction d'agrégation et générer un tableau (option "Grouper par en tant que nouveau tableau"). Dans ce cas, les données sont agrégées au niveau du groupe et nous perdons les détails de chaque transaction individuelle. Nous pouvons également choisir de conserver à la fois les détails et les valeurs agrégées dans le même ensemble de données (option "Regrouper par" en tant que nouvelle colonne), ce qui est très pratique pour appliquer un ratio (par exemple, le pourcentage de contribution d'une catégorie de produits au revenu global). Pour tester ce comportement, modifiez l'étape 7 de la recette et sélectionnez l'option "Grouper par en tant que nouveau tableau" ou "Grouper par en tant que nouvelle colonne" pour voir les différences.
  3. Joindre la date de tarification : enfin, une jointure est utilisée pour combiner plusieurs ensembles de données en un plus grand, en ajoutant des colonnes à l'ensemble de données initial. Dans cette étape, les données tarifaires sont jointes à la sortie de la recette de données transactionnelles en fonction de "Pricing Data.Product Code" = "Transaction Data.SKU" et "Pricing Data.Price Date" = "Transaction Data.Fiscal Date".

Pour en savoir plus sur les transformations que vous pouvez appliquer avec Dataprep, consultez la fiche mémo sur la préparation des données Trifacta.

8. Explorer la recette de mappage de schéma

La dernière recette, "Mappage du schéma", garantit que la table CDM résultante correspond au schéma de la table de sortie BigQuery existante. Ici, la fonctionnalité Cible rapide est utilisée pour reformater la structure des données afin qu'elle corresponde à la table BigQuery. Pour ce faire, elle utilise la correspondance approximative pour comparer les deux schémas et appliquer les modifications automatiquement.

9. Unifier dans une seule structure

Maintenant que les sources et les destinations ont été configurées, et que les étapes des flux ont été explorées, vous pouvez exécuter le flux pour transformer et charger la table CDM dans BigQuery.

  1. Exécuter la sortie du mappage de schéma : dans la vue du flux, sélectionnez l'objet de sortie du mappage de schéma, puis cliquez sur le bouton "Exécuter" dans le panneau "Détails". Sélectionnez l'environnement d'exécution "Trifacta Photon", puis décochez "Ignorer les erreurs de recette". Cliquez ensuite sur le bouton "Exécuter". Si la table BigQuery spécifiée existe, Dataprep ajoute de nouvelles lignes. Sinon, il crée une table.
  2. Afficher l'état du job : Dataprep ouvre automatiquement la page "Exécuter le job" pour vous permettre de surveiller l'exécution du job. L'opération devrait prendre quelques minutes. Une fois le job terminé, le résultat du CDM de tarification est chargé dans BigQuery dans un format propre, structuré et normalisé, prêt à être analysé.

10. Fournir des analyses et du ML/de l'IA

Conditions préalables pour Analytics

Afin d'exécuter des analyses et un modèle prédictif avec des résultats intéressants, nous avons créé un ensemble de données plus volumineux et pertinent pour découvrir des insights spécifiques. Vous devez importer ces données dans votre ensemble de données BigQuery avant de continuer ce guide.

Cliquez sur le bouton "+ Créer une table" et définissez les paramètres suivants :

  • Créez un tableau à partir de l'importation et sélectionnez le fichier CDM_Pricing_Large_Table.csv.
  • Détection automatique du schéma : cochez "Schéma et paramètres d'entrée".
  • Options avancées, Préférence d'écriture, Écraser la table

ff9ec8b9f580b139.png

  • Cliquez sur "Créer une table".

Une fois la table créée et les données importées, vous devriez voir les détails de la nouvelle table dans la console Google pour BigQuery, comme indiqué ci-dessous. Grâce aux données tarifaires dans BigQuery, nous pouvons facilement poser des questions plus complètes pour analyser vos données tarifaires de manière plus approfondie.

93e4c05972af1999.png

11. Afficher l'effet des modifications de prix

Par exemple, vous pouvez analyser l'évolution du comportement des commandes lorsque vous avez précédemment modifié le prix d'un article.

  1. Vous allez commencer par créer une table temporaire qui comporte une ligne chaque fois que le prix d'un produit a changé. Elle contient des informations sur la tarification de ce produit, comme le nombre d'articles commandés à chaque prix et le total des ventes nettes associées à ce prix.
create temp table price_changes as (
select
       product_id,
       list_price_converged,
       total_ordered_pieces,
       total_net_sales,
       first_price_date,
       lag(list_price_converged) over(partition by product_id order by first_price_date asc) as previous_list,
       lag(total_ordered_pieces) over(partition by product_id order by first_price_date asc) as previous_total_ordered_pieces,
       lag(total_net_sales) over(partition by product_id order by first_price_date asc) as previous_total_net_sales,
       lag(first_price_date) over(partition by product_id order by first_price_date asc) as previous_first_price_date
       from (
           select
               product_id,list_price_converged,sum(invoiced_quantity_in_pieces) as total_ordered_pieces, sum(net_sales) as total_net_sales, min(fiscal_date) as first_price_date
           from `{{my_project}}.{{my_dataset}}.CDM_Pricing` AS cdm_pricing
           group by 1,2
           order by 1, 2 asc
       )
);
select * from price_changes where previous_list is not null order by product_id, first_price_date desc

b320ba40f0692826.png

  1. Ensuite, une fois la table temporaire en place, vous pouvez calculer la variation moyenne des prix pour les SKU :
select avg((previous_list-list_price_converged)/nullif(previous_list,0))*100 as average_price_change from price_changes;
  1. Enfin, vous pouvez analyser ce qui se passe après une modification de prix en examinant la relation entre chaque modification de prix et le nombre total d'articles commandés :
select
(total_ordered_pieces-previous_total_ordered_pieces)/nullif(previous_total_ordered_pieces,0)

as

price_changes_percent_ordered_change,
(list_price_converged-previous_list)/nullif(previous_list,0)

as

price_changes_percent_price_change
from price_changes

12. Créer un modèle de prévision de séries temporelles

Ensuite, grâce aux fonctionnalités de machine learning intégrées à BigQuery, vous pouvez créer un modèle de prévision de série temporelle ARIMA pour prédire la quantité de chaque article qui sera vendue.

  1. Commencez par créer un modèle ARIMA_PLUS.
create or replace `{{my_project}}.{{my_dataset}}.bqml_arima`
options
 (model_type = 'ARIMA_PLUS',
  time_series_timestamp_col = 'fiscal_date',
  time_series_data_col = 'total_quantity',
  time_series_id_col = 'product_id',
  auto_arima = TRUE,
  data_frequency = 'AUTO_FREQUENCY',
  decompose_time_series = TRUE
 ) as
select
 fiscal_date,
 product_id,
 sum(invoiced_quantity_in_pieces) as total_quantity
from
 `{{my_project}}.{{my_dataset}}.CDM_Pricing` 
group by 1,2;
  1. Vous allez ensuite prédire les futures ventes de chaque produit à l'aide de la fonction ML.FORECAST :
select
*
from
ML.FORECAST(model testing.bqml_arima,
            struct(30 as horizon, 0.8 as confidence_level));
  1. Grâce à ces prédictions, vous pouvez essayer de comprendre ce qui pourrait se passer si vous augmentiez vos prix. Par exemple, si vous augmentez le prix de chaque produit de 15 %, vous pouvez calculer le revenu total estimé pour le mois prochain à l'aide d'une requête comme celle-ci :
select
sum(forecast_value * list_price) as total_revenue
from ml.forecast(mode testing.bqml_arima,
            struct(30 as horizon, 0.8 as confidence_level)) forecasts
left join (select product_id,
                array_agg(list_price_converged
                       order by fiscal_date desc limit 1)[offset(0)] as list_price
                from `leigha-bq-dev.retail.cdm_pricing` group by 1)  recent_prices
using (product_id);

13. Générer un rapport

Maintenant que vos données tarifaires dénormalisées sont centralisées dans BigQuery et que vous savez comment exécuter des requêtes pertinentes sur ces données, il est temps de créer un rapport pour permettre aux utilisateurs professionnels d'explorer ces informations et d'agir en conséquence.

Si vous disposez déjà d'une instance Looker, vous pouvez utiliser le LookML de ce dépôt GitHub pour commencer à analyser les données tarifaires de ce modèle. Il vous suffit de créer un projet Looker, d'ajouter le LookML, puis de remplacer les noms de connexion et de table dans chacun des fichiers view pour qu'ils correspondent à votre configuration BigQuery.

Dans ce modèle, vous trouverez la table dérivée ( dans ce fichier de vue) que nous avons montrée précédemment pour examiner les variations de prix :

view: price_changes {
    derived_table: {
      sql: select
        product_id,
        list_price_converged,
        total_ordered_pieces,
        total_net_sales,
        first_price_date,
        lag(list_price_converged) over(partition by product_id order by first_price_date asc) as previous_list,
        lag(total_ordered_pieces) over(partition by product_id order by first_price_date asc) as previous_total_ordered_pieces,
        lag(total_net_sales) over(partition by product_id order by first_price_date asc) as previous_total_net_sales,
        lag(first_price_date) over(partition by product_id order by first_price_date asc) as previous_first_price_date
        from (
      select
         product_id,list_price_converged,sum(invoiced_quantity_in_pieces) as total_ordered_pieces, sum(net_sales) as total_net_sales, min(fiscal_date) as first_price_date
      from ${cdm_pricing.SQL_TABLE_NAME}  AS cdm_pricing
      group by 1,2
      order by 1, 2 asc
      )
       ;;
    }
...

}

En plus du modèle BigQuery ML ARIMA que nous avons présenté plus tôt, pour prédire les ventes futures ( dans ce fichier de vue)

view: arima_model {
  derived_table: {
    persist_for: "24 hours"
    sql_create:
      create or replace model ${sql_table_name}
            options
              (model_type = 'arima_plus',
               time_series_timestamp_col = 'fiscal_date',
               time_series_data_col = 'total_quantity',
               time_series_id_col = 'product_id',
               auto_arima = true,
               data_frequency = 'auto_frequency',
               decompose_time_series = true
              ) as
            select
              fiscal_date,
              product_id,
              sum(invoiced_quantity_in_pieces) as total_quantity
            from
              ${cdm_pricing.sql_table_name}
            group by 1,2 ;;
          }
   }
...
}

Le code LookML contient également un exemple de tableau de bord. Cliquez ici pour accéder à une version de démonstration du tableau de bord. La première partie du tableau de bord fournit aux utilisateurs des informations générales sur les variations des ventes, des coûts, des prix et des marges. En tant qu'utilisateur professionnel, vous pouvez créer une alerte pour savoir si les ventes ont chuté de plus de X %, car cela peut signifier que vous devez baisser vos prix.

b531e169b192c111.png

La section suivante, illustrée ci-dessous, permet aux utilisateurs d'analyser les tendances liées aux changements de prix. Vous pouvez ici examiner des produits spécifiques pour connaître leur prix catalogue exact et les nouveaux prix. Cela peut vous aider à identifier des produits spécifiques sur lesquels effectuer des recherches plus approfondies.

6a98666697aa7a1.gif

Enfin, en bas du rapport, vous trouverez les résultats de notre modèle BigQueryML. En utilisant les filtres en haut du tableau de bord Looker, vous pouvez facilement saisir des paramètres pour simuler différents scénarios, comme décrit ci-dessus. Par exemple, vous pouvez voir ce qui se passerait si le volume de commandes diminuait de 25 % par rapport à la valeur prédite et si le prix de tous les produits augmentait de 25 %, comme indiqué ci-dessous.

d3a9d37c89c39b99.gif

Il s'appuie sur les paramètres de LookML, qui sont ensuite intégrés directement dans les calculs des mesures disponibles ici.  Ce type de rapport vous permet de trouver le prix optimal pour tous les produits ou d'analyser des produits spécifiques pour déterminer où vous devriez augmenter ou baisser les prix, et quel serait l'impact sur les revenus bruts et nets.

14. S'adapter à vos systèmes de tarification

Bien que ce tutoriel transforme des exemples de sources de données, vous rencontrerez des problèmes de données très similaires pour les composants de tarification qui se trouvent sur vos différentes plates-formes. Les composants de tarification ont différents formats d'exportation (souvent xls, Sheets, csv, txt, bases de données relationnelles, applications métier) pour les résultats récapitulatifs et détaillés, chacun pouvant être connecté à Dataprep. Nous vous recommandons de commencer par décrire vos besoins de transformation de la même manière que dans les exemples ci-dessus. Une fois vos spécifications clarifiées et les types de transformations nécessaires identifiés, vous pouvez les concevoir avec Dataprep.

  1. Créez une copie du flux Dataprep que vous allez personnaliser (cliquez sur le bouton "... " (Plus) à droite du flux, puis sélectionnez l'option "Dupliquer"), ou partez de zéro en utilisant un nouveau flux Dataprep.
  2. Connectez-vous à votre propre ensemble de données tarifaires. Dataprep est compatible en mode natif avec les formats de fichiers tels qu'Excel, CSV, Google Sheets et JSON. Vous pouvez également vous connecter à d'autres systèmes à l'aide des connecteurs Dataprep.
  3. Répartissez vos composants de données dans les différentes catégories de transformation que vous avez identifiées. Créez une recette pour chaque catégorie. Inspirez-vous du flux fourni dans ce modèle de conception pour transformer les données et écrire vos propres recettes. Si vous êtes bloqué, pas de panique ! Demandez de l'aide dans la boîte de dialogue en bas à gauche de l'écran Préparation des données.
  4. Connectez votre recette à votre instance BigQuery. Vous n'avez pas besoin de créer manuellement les tables dans BigQuery. Dataprep s'en chargera automatiquement. Lorsque vous ajoutez la sortie à votre flux, nous vous suggérons de sélectionner une destination manuelle et de supprimer la table à chaque exécution. Testez chaque recette individuellement jusqu'à ce que vous obteniez les résultats attendus. Une fois vos tests terminés, vous convertirez la sortie en "Ajouter à la table à chaque exécution" pour éviter de supprimer les données précédentes.
  5. Vous pouvez également associer le flux à une planification. Cela peut être utile si votre processus doit s'exécuter en continu. Vous pouvez définir une programmation pour charger la réponse tous les jours ou toutes les heures en fonction de la fraîcheur requise. Si vous décidez d'exécuter le flux selon une planification, vous devrez ajouter une sortie de destination de planification dans le flux pour chaque recette.

Modifier le modèle BigQuery Machine Learning

Ce tutoriel fournit un exemple de modèle ARIMA. Toutefois, vous pouvez contrôler d'autres paramètres lorsque vous développez le modèle pour vous assurer qu'il s'adapte au mieux à vos données. Pour en savoir plus, consultez l' exemple de notre documentation.  Vous pouvez également utiliser les fonctions BigQuery ML.ARIMA_EVALUATE, ML.ARIMA_COEFFICIENTS et ML.EXPLAIN_FORECAST pour obtenir plus d'informations sur votre modèle et prendre des décisions d'optimisation.

Modifier les rapports Looker

Après avoir importé le LookML dans votre propre projet comme décrit ci-dessus, vous pouvez le modifier directement pour ajouter des champs, modifier des calculs ou des paramètres saisis par l'utilisateur, et changer les visualisations des tableaux de bord en fonction des besoins de votre entreprise. Pour en savoir plus sur le développement dans LookML et la visualisation des données dans Looker , consultez les liens correspondants.

15. Félicitations

Vous connaissez désormais les principales étapes nécessaires pour optimiser le prix de vos produits.

Et ensuite ?

Découvrez d'autres modèles de référence pour les analyses intelligentes.

Complément d'informations