Daten auf geografischer Ebene ohne 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, revenue_per_kpi, media und media_spend. 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',
        'Channel4_impression',
        'Channel5_impression',
    ],
    media_spend=[
        'Channel0_spend',
        'Channel1_spend',
        'Channel2_spend',
        'Channel3_spend',
        'Channel4_spend',
        'Channel5_spend',
    ],
)

  2. Ordnen Sie die Media-Variablen und ‑Ausgaben den angegebenen Channel-Namen zu, die in der zweiseitigen Ausgabe angezeigt werden sollen. Im folgenden Beispiel sind Channel0_impression und Channel0_spend mit demselben Channel (Channel0) verbunden.

    correct_media_to_channel = {
    'Channel0_impression': 'Channel0',
    'Channel1_impression': 'Channel1',
    'Channel2_impression': 'Channel2',
    'Channel3_impression': 'Channel3',
    'Channel4_impression': 'Channel4',
    'Channel5_impression': 'Channel5',
}
correct_media_spend_to_channel = {
    'Channel0_spend': 'Channel0',
    'Channel1_spend': 'Channel1',
    'Channel2_spend': 'Channel2',
    'Channel3_spend': 'Channel3',
    '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,
    currency_code='USD',
)
data = loader.load()

    Dabei gilt:

    • kpi_type ist entweder 'revenue' oder 'non_revenue'.
    • currency_code (optional) ist ein dreistelliger ISO 4217-Währungscode (z. B. 'USD', 'EUR', 'GBP'), der die Währungseinheit für Ausgaben und Umsatz angibt. Wenn diese Option festgelegt ist, formatieren Berichtsvisualisierer Geldwerte automatisch mit dem entsprechenden Währungssymbol.
    • 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 und media_channel. Die Namen der erforderlichen Datenvariablen sind kpi, revenue_per_kpi, controls, population, media und media_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',
    },
)

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]])
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]],
])

  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_media(
      m_nd=media_nd,
      ms_nd=media_spend_nd,
      media_channels=["channel0", "channel1"]
    )
)

data = builder.build()

    Dabei gilt:

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

Pandas-DataFrames 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.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.currency_code = 'USD'
builder = (
    builder
        .with_kpi(df)
        .with_revenue_per_kpi(df)
        .with_population(df)
        .with_controls(df, control_cols=["GQV", "Discount", "Competitor_Sales"])
)
channels = ["Channel0", "Channel1", "Channel2", "Channel3", "Channel4", "Channel5"]
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,
)

data = builder.build()

    Dabei gilt:

    • kpi_type ist entweder 'revenue' oder 'non_revenue'.
    • currency_code ist der optionale ISO 4217-Währungscode (z. B. 'USD').

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

Zurück
Unterstützte Datentypen und ‑formate
Weiter
Daten auf geografischer Ebene mit Reichweite und Häufigkeit laden