Daten auf geografischer Ebene mit Reichweite und Häufigkeit laden

In den folgenden Abschnitten werden für jeden Datentyp und jedes Format simulierte Daten als Beispiel zur Verfügung gestellt.

CSV

So laden Sie die simulierten CSV-Daten mit CsvDataLoader:

  1. Ordnen Sie die Spaltennamen den Variablentypen zu. Die erforderlichen Variablentypen sind time, geo, controls, population, kpi und revenue_per_kpi. Für Media-Channels, für die keine Daten zu Reichweite und Häufigkeit vorliegen, müssen Sie die Media-Präsenz und die Media-Ausgaben den Kategorien media bzw. media_spend zuweisen. Bei Media-Channels mit Reichweiten- und Häufigkeitsdaten müssen Sie die Reichweite, Häufigkeit und Media-Ausgaben den Kategorien reach, frequency und rf_spend zuordnen. Die Definition der einzelnen Variablen finden Sie unter Daten erheben und organisieren.

    coord_to_columns = load.CoordToColumns(
    time='time',
    geo='geo',
    controls=['GQV', 'Discount', 'Competitor_Sales'],
    population='population',
    kpi='conversions',
    revenue_per_kpi='revenue_per_conversion',
    media=[
        'Channel0_impression',
        'Channel1_impression',
        'Channel2_impression',
        'Channel3_impression',
    ],
    media_spend=[
        'Channel0_spend',
        'Channel1_spend',
        'Channel2_spend',
        'Channel3_spend',
    ],
    reach =['Channel4_reach', 'Channel5_reach'],
    frequency=['Channel4_frequency', 'Channel5_frequency'],
    rf_spend=['Channel4_spend', 'Channel5_spend'],
)

  2. Ordnen Sie die Media-Präsenz, Reichweite, Häufigkeit und Media-Ausgaben den angegebenen Channelnamen zu, die in der zweiseitigen Ausgabe angezeigt werden sollen. Im folgenden Beispiel sind Channel0_impression und Channel0_spend mit demselben Channel (Channel0) verbunden. Außerdem sind Channel4_reach, Channel4_frequency und Channel4_spend mit demselben Channel (Channel4) verbunden.

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

correct_reach_to_channel = {
    'Channel4_reach': 'Channel4',
    'Channel5_reach': 'Channel5',
}
correct_frequency_to_channel = {
    'Channel4_frequency': 'Channel4',
    'Channel5_frequency': 'Channel5',
}
correct_rf_spend_to_channel = {
    'Channel4_spend': 'Channel4',
    'Channel5_spend': 'Channel5',
}

  3. Laden Sie die Daten mit 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,
    reach_to_channel=correct_reach_to_channel,
    frequency_to_channel=correct_frequency_to_channel,
    rf_spend_to_channel=correct_rf_spend_to_channel,
)
data = loader.load()

    Dabei gilt:

    • kpi_type ist entweder 'revenue' oder 'non_revenue'.
    • PATH ist der Pfad zum Speicherort der Datendatei.
    • FILENAME ist der Name Ihrer Datendatei.

Xarray-Dataset

So laden Sie das serialisierte (pickled) simulierte Xarray-Dataset mit XrDatasetDataLoader:

  1. Laden Sie die Daten mit pickle:

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

    Dabei gilt:

    • PATH ist der Pfad zum Speicherort der Datendatei.
    • FILENAME ist der Name Ihrer Datendatei.

  2. Übergeben Sie das Dataset an XrDatasetDataLoader. Verwenden Sie das Argument name_mapping, um die Koordinaten und Arrays zuzuordnen. Geben Sie eine Zuordnung an, wenn sich die Namen im Dataset für die Eingabe von den erforderlichen Namen unterscheiden. Die Namen der erforderlichen Koordinaten sind geo, time, control_variable, media_channel und rf_channel. Dabei steht rf_channel für die Channels mit Daten zu Reichweite und Häufigkeit. Die Namen der erforderlichen Datenvariablen sind kpi, revenue_per_kpi, controls, population, media, media_spend, reach, frequency und rf_spend.

    loader = load.XrDatasetDataLoader(
    dataset,
    kpi_type='non_revenue',
    name_mapping={
        'channel': 'media_channel',
        'control': 'control_variable',
        'conversions': 'kpi',
        'revenue_per_conversion': 'revenue_per_kpi',
        'control_value': 'controls',
        'spend': 'media_spend',
        'reach': 'reach',
        'frequency': 'frequency',
        'rf_spend': 'rf_spend',
    },
)

data = loader.load()

    Dabei gilt:

    • kpi_type ist entweder 'revenue' oder 'non_revenue'.

N-dimensionales Array von NumPy

Wenn Sie n-dimensionale Arrays von NumPy direkt laden möchten, verwenden Sie NDArrayInputDataBuilder:

  1. Erstellen Sie die Daten in separaten n-dimensionalen Arrays von NumPy.

    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]])
reach_nd = np.array([
  [[1, 5], [2, 6], [3, 4]],
  [[7, 8], [9, 10], [11, 12]],
  [[13, 14], [15, 16], [17, 18]],
])
frequency_nd = np.array([
  [[1, 5], [2, 6], [3, 4]],
  [[7, 8], [9, 10], [11, 12]],
  [[13, 14], [15, 16], [17, 18]],
])
rf_spend_nd = np.array([
  [[1, 5], [2, 6], [3, 4]],
  [[7, 8], [9, 10], [11, 12]],
  [[13, 14], [15, 16], [17, 18]],
])

  2. Verwenden Sie einen NDArrayInputDataBuilder, um Zeit und geografische Einheiten festzulegen und Channel- oder Dimensionsnamen anzugeben, wie in Meridian-Eingabedaten erforderlich. Die Definition der einzelnen Variablen finden Sie unter Daten erheben und organisieren.

    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_reach(
        r_nd=reach_nd,
        f_nd=frequency_nd,
        rfs_nd=rf_spend_nd,
        rf_channels=["channel0", "channel1"]
    )
)

data = builder.build()

    Dabei gilt:

    • kpi_type ist entweder 'revenue' oder 'non_revenue'.

Pandas-DataFrame oder andere Datenformate

So laden Sie ein anderes Format für simulierte Daten (z. B. excel) mit DataFrameInputDataBuilder:

  1. Lesen Sie die Daten (z. B. eine excel-Tabelle) in ein oder mehrere Pandas-DataFrames ein.

    import pandas as pd

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

  2. Verwenden Sie einen DataFrameInputDataBuilder, um Spaltennamen den Variablentypen zuzuordnen, die in Meridian-Eingabedaten erforderlich sind. Die Definition der einzelnen Variablen finden Sie unter Daten erheben und organisieren.

    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", "Discount", "Competitor_Sales"])
        .with_reach(
            df,
            reach_cols = ['Channel4_reach', 'Channel5_reach'],
            frequency_cols = ['Channel4_frequency', 'Channel5_frequency'],
            rf_spend_cols = ['Channel4_spend', 'Channel5_spend'],
            rf_channels = ['Channel4', 'Channel5'],
        )
)

data = builder.build()

    Dabei gilt:

    • kpi_type ist entweder 'revenue' oder 'non_revenue'.

Als Nächstes können Sie Ihr Modell erstellen.

Zurück
Daten auf geografischer Ebene ohne Reichweite und Häufigkeit laden
Weiter
Daten auf geografischer Ebene mit organischen Media- und nicht mediabezogenen Testvariablen laden