Cómo cargar datos a nivel de la ubicación geográfica con tratamientos de medios orgánicos y no relacionados con los medios

Se proporcionan datos simulados como ejemplo para cada tipo y formato de datos en las siguientes secciones:

CSV

Para cargar los datos de CSV simulados con CsvDataLoader, haz lo siguiente:

1. Asocia los nombres de las columnas con los tipos de variables. Los tipos de variables requeridos son time, geo, controls, population, kpi, revenue_per_kpi, media y media_spend. Para los canales de medios que no tienen un costo directo, debes asignar su exposición a organic_media. Para los tratamientos que no son de medios, debes asignar los nombres de las columnas correspondientes a non_media_treatments. Para obtener la definición de cada variable, consulta Cómo recopilar y organizar tus datos.

   coord_to_columns = load.CoordToColumns(
       time='time',
       geo='geo',
       controls=['GQV', 'Competitor_Sales'],
       population='population',
       kpi='conversions',
       revenue_per_kpi='revenue_per_conversion',
       media=[
           'Channel0_impression',
           'Channel1_impression',
           'Channel2_impression',
           'Channel3_impression',
           'Channel4_impression',
       ],
       media_spend=[
           'Channel0_spend',
           'Channel1_spend',
           'Channel2_spend',
           'Channel3_spend',
           'Channel4_spend',
       ],
       organic_media=['Organic_channel0_impression'],
       non_media_treatments=['Promo'],
   )
   

2. Asocia las variables de medios y las inversiones en medios con los nombres de los canales designados que deseas mostrar en el resultado de dos páginas. En el siguiente ejemplo, Channel0_impression y Channel0_spend están conectados al mismo canal, Channel0.

   correct_media_to_channel = {
       'Channel0_impression': 'Channel0',
       'Channel1_impression': 'Channel1',
       'Channel2_impression': 'Channel2',
       'Channel3_impression': 'Channel3',
       'Channel4_impression': 'Channel4',
   }
   correct_media_spend_to_channel = {
       'Channel0_spend': 'Channel0',
       'Channel1_spend': 'Channel1',
       'Channel2_spend': 'Channel2',
       'Channel3_spend': 'Channel3',
       'Channel4_spend': 'Channel4',
   }
   

3. Carga los datos con CsvDataLoader:

   loader = load.CsvDataLoader(
       csv_path=f'/{PATH}/{FILENAME}.csv',
       kpi_type='non_revenue',
       coord_to_columns=coord_to_columns,
       media_to_channel=correct_media_to_channel,
       media_spend_to_channel=correct_media_spend_to_channel,
   )
   data = loader.load()
   

   Donde:

   • kpi_type es 'revenue' o 'non_revenue'.
   • PATH es la ruta de acceso a la ubicación del archivo de datos.
   • FILENAME es el nombre de tu archivo de datos.

Conjunto de datos Xarray

Para cargar el conjunto de datos Xarray simulado con XrDatasetDataLoader, haz lo siguiente:

1. Carga los datos con pickle:

   import pickle
   with open(f'/{PATH}/{FILENAME}.pkl', 'r') as fh:
     XrDataset=pickle.load(fh)
   

   Donde:

   • PATH es la ruta de acceso a la ubicación del archivo de datos.
   • FILENAME es el nombre de tu archivo de datos.

2. Pasa el conjunto de datos a XrDatasetDataLoader. Usa el argumento name_mapping para asociar las coordenadas y los arrays. Procede a la asociación si los nombres incluidos en el conjunto de datos de entrada no coinciden con los nombres requeridos. Los nombres de las coordenadas son geo, time, control_variable, media_channel, organic_media_channel y non_media_channel. Los nombres de las variables de datos requeridos son kpi, revenue_per_kpi, controls, population, media, media_spend, organic_media y non_media_treatments.

   loader = load.XrDatasetDataLoader(
       XrDataset,
       kpi_type='non_revenue',
       name_mapping={'channel': 'media_channel',
                     'control': 'control_variable',
                     'organic_channel': 'organic_media_channel',
                     'non_media_treatment': 'non_media_channel',
                     'conversions': 'kpi',
                     'revenue_per_conversion': 'revenue_per_kpi',
                     'control_value': 'controls',
                     'spend': 'media_spend',
                     'non_media_treatment_value': 'non_media_treatments'},
   )
   
   data = loader.load()
   

   Donde:

   • kpi_type es 'revenue' o 'non_revenue'.

Ndarray de NumPy

Para cargar ndarrays de numPy directamente, usa NDArrayInputDataBuilder:

1. Crea los datos en ndarrays de numPy separados.

   import numpy as np
   
   kpi_nd = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
   controls_nd = np.array([
     [[1, 5], [2, 6], [3, 4]],
     [[7, 8], [9, 10], [11, 12]],
     [[13, 14], [15, 16], [17, 18]],
   ])
   population_nd = np.array([1, 2, 3])
   revenue_per_kpi_nd = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
   media_nd = np.array([
     [[1, 5], [2, 6], [3, 4]],
     [[7, 8], [9, 10], [11, 12]],
     [[13, 14], [15, 16], [17, 18]],
   ])
   media_spend_nd = np.array([
     [[1, 5], [2, 6], [3, 4]],
     [[7, 8], [9, 10], [11, 12]],
     [[13, 14], [15, 16], [17, 18]],
   ])
   organic_media_nd = np.array([
     [[1, 5], [2, 6], [3, 4]],
     [[7, 8], [9, 10], [11, 12]],
     [[13, 14], [15, 16], [17, 18]],
   ])
   non_media_treatments_nd = np.array([
     [[1, 5], [2, 6], [3, 4]],
     [[7, 8], [9, 10], [11, 12]],
     [[13, 14], [15, 16], [17, 18]],
   ])
   

2. Usa un NDArrayInputDataBuilder para establecer la hora y las ubicaciones geográficas, así como para asignar nombres de canales o dimensiones según sea necesario en los datos de entrada de Meridian. Para conocer la definición de cada variable, consulta Cómo recopilar y organizar tus datos.

   from meridian.data import nd_array_input_data_builder as data_builder
   
   builder = (
       data_builder.NDArrayInputDataBuilder(kpi_type='non_revenue')
   )
   builder.time_coords = ['2024-01-02', '2024-01-03', '2024-01-01']
   builder.media_time_coords = ['2024-01-02', '2024-01-03', '2024-01-01']
   builder.geos = ['B', 'A', 'C']
   builder = (
     builder
       .with_kpi(kpi_nd)
       .with_revenue_per_kpi(revenue_per_kpi_nd)
       .with_population(population_nd)
       .with_controls(
         controls_nd,
         control_names=["control0", "control1"])
       .with_media(
         m_nd=media_nd,
         ms_nd=media_spend_nd,
         media_channels=["channel0", "channel1"]
       )
       .with_organic_media(
         organic_media_nd,
         organic_media_channels=["organic_channel0", "organic_channel1"]
       ).with_non_media_treatments(
         non_media_treatments_nd,
         non_media_channel_names=["non_media_channel0", "non_media_channel1"]
       )
   )
   
   data = builder.build()
   

   Donde:

   • kpi_type es 'revenue' o 'non_revenue'.

DataFrame de Pandas o cualquier otro formato de datos

Para cargar otro formato de datos simulados (como excel) con DataFrameInputDataBuilder, haz lo siguiente:

1. Lee los datos (como una hoja de cálculo de excel) en uno o más DataFrame de Pandas.

   import pandas as pd
   
   df = pd.read_excel(
       'https://github.com/google/meridian/raw/main/meridian/data/simulated_data/xlsx/geo_all_channels.xlsx',
       engine='openpyxl',
   )
   

2. Usa DataFrameInputDataBuilder para asociar los nombres de las columnas con los tipos de variables requeridos en los datos de entrada de Meridian. Para conocer la definición de cada variable, consulta Cómo recopilar y organizar tus datos.

   from meridian.data import data_frame_input_data_builder as data_builder
   
   builder = data_builder.DataFrameInputDataBuilder(
       kpi_type='non_revenue',
       default_kpi_column="conversions",
       default_revenue_per_kpi_column="revenue_per_conversion",
   )
   builder = (
       builder
           .with_kpi(df)
           .with_revenue_per_kpi(df)
           .with_population(df)
           .with_controls(df, control_cols=["GQV", "Competitor_Sales"])
   )
   channels = ["Channel0", "Channel1", "Channel2", "Channel3", "Channel4"]
   builder = builder.with_media(
       df,
       media_cols=[f"{channel}_impression" for channel in channels],
       media_spend_cols=[f"{channel}_spend" for channel in channels],
       media_channels=channels,
   )
   builder = (
       builder
           .with_organic_media(
               df,
               organic_media_cols = ["Organic_channel0_impression"],
               organic_media_channels = ["Organic_channel0"],
           )
           .with_non_media_treatments(
               df,
               non_media_treatment_cols=['Promo']
           )
   )
   
   data = builder.build()
   

   Donde:

   • kpi_type es 'revenue' o 'non_revenue'.

A continuación, puedes crear tu modelo.