Big Data

Preisempfehlungs-App mit Python

“Der Moment, in dem Sie einen Preisfehler machen, erodiert Ihren Ruf oder Ihre Gewinne”. – Katharine Paine

Die Preisoptimierung besteht darin, historische Daten zu verwenden, um den am besten geeigneten Preis eines Produkts oder einer Dienstleistung zu ermitteln, der die Rentabilität des Unternehmens maximiert. Es gibt zahlreiche Faktoren wie Demografie, Betriebskosten, Umfragedaten, etc. die eine Rolle bei der effizienten Preisgestaltung spielen, es hängt auch von der Art der Unternehmen und dem Produkt ab, das bedient wird. Das Unternehmen fügt hinzu / Aktualisieren Sie die Funktionen regelmäßig, um dem Produkt mehr Wert zu verleihen und, offensichtlich, das ist mit Aufwand verbunden, Zeit und, das wichtigste, der Ruf von Unternehmen.

Infolge, Es ist wichtig, den richtigen Preis zu verstehen, etwas zu hoch, Sie verlieren Ihre Kunden und eine leichte Unterbewertung führt zu Umsatzeinbußen. Preisoptimierung hilft Unternehmen, die richtige Balance zwischen effizienten Preisen zu finden, Gewinnziele erreichen und auch Ihre Kunden bedienen. In diesem Blog, wir werden uns den vereinfachten Ansatz zur Preisoptimierung ansehen und auch eine Simulationsanwendung erstellen.

Abbildung 1: Schnappschuss der Preisempfehlungs-App

Herausforderungen bei der Preisoptimierung:

Preisoptimierung für ein einzelnes Produkt: Die Preisoptimierung für ein einzelnes Produkt sagt eine sich ändernde Nachfrage als Reaktion auf unterschiedliche Preise vorher. Hilft dem Unternehmen, die Preise festzulegen, die die Kunden zu zahlen bereit sind, und den Gewinn zu maximieren. Zum Beispiel: auf dem Smartphone-Markt, Es ist ein gutes Gleichgewicht zwischen neuen Funktionen und Preis.

Preisoptimierung für eine Produktfamilie: Jede Preisänderung eines Produkts kann eine Kettenreaktion in einer Produktfamilie auslösen. Deswegen, Die Preisgestaltung für Produktfamilien wird zu einer entmutigenden Aufgabe. Nicht .: Auf dem Eismarkt, Es kann verschiedene Geschmacksrichtungen geben, Größen wie in Tassen, Bonbons, Zapfen, packs familiares o tarrinas. Es ist das gleiche Produkt mit unterschiedlichen Größen und Preisen.

Vorteile der Preisoptimierung:

Sofortiger wirtschaftlicher Nutzen: Unternehmen können sofortige Ergebnisse erzielen, indem sie auf mehrere KPIs abzielen, entweder Rand, Umsatzumwandlungen, Hinzufügen neuer Kunden oder Eintritt in einen neuen Markt, etc., und überprüfen Sie dann die Ergebnisse, um die entsprechenden Preisänderungen vorzunehmen.

Automatisierung von Geschäftsprozessen: Preisoptimierungen sollten eher ein datengesteuerter Prozess sein. Historische Datenanalyse, Verkaufstrends, Anforderung, etc. hilft Unternehmen beim Entwerfen von Regeln oder beim Erstellen von ML-Modellen oder beim Erstellen eines Hybridmodells, das vollständig automatisiert ist, Dadurch werden menschliche Fehler oder emotionsbasierte Preisentscheidungen eliminiert.

Schnelle Reaktion auf sich ändernde Markttrends: Die Nachfrage und der Markttrend ändern sich recht häufig und, manchmal, wenn ein Wettbewerber ein ähnliches Produkt zu einem niedrigeren Preis auf den Markt bringt, frisst die Handlungen anderer. In einem solchen Szenario, Die Optimierung der Produktpreise in einem bestimmten Produktsegment oder einer bestimmten Region hilft Unternehmen, diese Herausforderung zu meistern.

Ziele:

Wir werden die nächsten Schritte erkunden und, am Ende dieses Blogs, wir werden die erstellen Preisoptimierungs-Simulator-App mit Handlungsskript.

Übersicht zur Preisoptimierung
Herausforderungen und Vorteile der Optimierung
Datenexploration
Modellbau und Optimierung
App-Entwicklung mit Plotly Dash
Herausforderungen bei der Erstellung und Implementierung von Preisoptimierungsmodellen und -anwendungen

Beginnend:

Daten: Wir werden Spielzeugdaten verwenden. Preis.csv und hier ist eine kurze Momentaufnahme der Daten. Da der Datensatz klein und sauber ist, keine Vorbearbeitung notwendig.

Jahr Quartal Menge Preis          
1977	1	22.9976	        142.1667
1977	2	22.6131	        143.9333
1977	3	23.4054	        146.5000
1977	4	22.7401	        150.8000
1978	1	22.0441	        160.0000
1978	2	21.7602	        182.5333
1978	3	21.6064	        186.2000
1978	4	21.8814	        186.4333
1979	1	20.5086	        211.7000
1979	2	19.0408	        231.5000

Projektstruktur: Hier ist die Struktur unseres Projekts.

Preisoptimierung

| app.py # Die Datei zum Erstellen von Apps mit Rückruflogik und Benutzeroberfläche

+ -Vermögenswerte # Das Stylesheet, das die Ästhetik der Anwendung definiert.

+ -Daten

| preis.csv # Die Datensatzdatei

+ -Python

| optimizar_precio.py # Die Python-Datei mit Logik zur Preisoptimierung.

| optimizar_cantidad.py # Die Python-Datei mit Logik zur Mengenoptimierung

Laden von Bibliotheken: Lassen Sie uns eine Datei nach Namen erstellen optimizar_precio.py und laden Sie alle notwendigen Bibliotheken.

Pandas als pd importieren
numpy als np importieren
von Pandas importieren DataFrame
import matplotlib.pyplot als plt
Seegeboren als sns importieren
aus statsmodels.formula.api import ols
importiere plotly.express als px
plotly.graph_objects als Go importieren

Schauen wir uns die Beziehung zwischen Preis und Menge an und wir erwarten einen linearen Trend.

fig_PriceVsQuantity = px.scatter(

df, x="Preis", y ="Menge", Farbe="Kosten", Trendlinie="ols")

fig_PriceVsQuantity.show()

Abbildung 2: Preis vs. Menge

Aufbau eines Basismodells: In unserem Fall, wir bauen ein OLS-Modell (Gewöhnlicher kleinster Platz) sehr einfach.

# passen OLS-Modell
Modell = ols("Menge ~ Preis", Daten=df).fit()

Optimierungsbereich: In den meisten Fällen, wir haben eine grobe Vorstellung von den Mindest- und Höchstpreisen aufgrund von Erfahrungen aus der Vergangenheit. Wie wir den besten Preis ermitteln, es wird ein guter Ausgangspunkt sein und wir werden es mit mehreren Iterationen weiter verfeinern.

  Preis = Liste(Bereich(var_range[0], var_range[1], 10))
    Kosten = int(var_kosten)
    Menge = []
    Umsatz = []
    für i im Preis:
        Nachfrage = model.params[0] + (model.params[1] * ich)
        Menge.anhängen(Anforderung)
        Umsatz.anhängen((ich koste) * Anforderung)

Wir erstellen einen Datenrahmen mit dem 3 Preisspalten, Einkommen und Betrag, mit dem wir während der Entwicklungsphase der Anwendung leicht auf diese Werte zugreifen können.

Gewinn = pd.DataFrame({"Preis": Preis, "Einnahmen": Einnahmen, "Menge": Anzahl})

max_val = profit.loc[(profitieren['Einnahmen'] == Gewinn['Einnahmen'].max())]

Optimierungsliniendiagramm: Hier ist die Funktion, die wir auf der Karte haben möchten.

Das Diagramm sollte basierend auf der Auswahl einer Preisspanne durch den Benutzer aktualisiert werden / Menge oder vielleicht ein Fixpreis.
Die Grafik sollte den genauen Punkt anzeigen, an dem das Einkommen am höchsten ist.

fig_PriceVsRevenue = go.Figure()
    fig_PriceVsRevenue.add_trace(go.Scatter(
        x=Gewinn['Preis'], y=Gewinn['Einnahmen']))
    fig_PriceVsRevenue.add_annotation(x=int(max_val['Preis']), y=int(max_val['Einnahmen']),
                                      text="Maximaler Umsatz",
                                      showarrow=Wahr,
                                      Pfeilspitze=1)
    fig_PriceVsRevenue.update_layout(
        showlegend=Falsch,
        xaxis_title="Preis",
        yaxis_title="Einnahmen")
    fig_PriceVsRevenue.add_vline(x=int(max_val['Preis']), line_width=2, line_dash="Bindestrich",
                                 line_color="rot", Deckkraft=0,25)

Abbildung 3: Preis vs. Einkommen

Alles zusammenfügen: Die Logik der Preisoptimierung wird in der Datei sein. optimizar_precio.py

Pandas als pd importieren
numpy als np importieren
von Pandas importieren DataFrame
import matplotlib.pyplot als plt
Seegeboren als sns importieren
aus statsmodels.formula.api import ols
importiere plotly.express als px
plotly.graph_objects als Go importieren
auf jeden Fall fun_optimize(var_opt, var_range, var_kosten, df):
    fig_PriceVsQuantity = px.scatter(
        df, x="Preis", y ="Menge", Farbe="Kosten", Trendlinie="ols")
    # passen OLS-Modell
    Modell = ols("Menge ~ Preis", Daten=df).fit()
    Preis = Liste(Bereich(var_range[0], var_range[1], 10))
    Kosten = int(var_kosten)
    Menge = []
    ......................
    ......................

    Rückkehr [profitieren, fig_PriceVsRevenue, fig_PreisVsMenge, runden(max_val['Preis'].Werte[0],2),runden(max_val['Einnahmen'].Werte[0],3)]

Mengenoptimierung: Wir werden einen ähnlichen Ansatz verfolgen, um die Höhe einer bestimmten Beschränkung für den maximalen Umsatz zu optimieren.. Der Kürze halber und damit der Blog nicht zu umfangreich wird, Ich werde den Code nicht in den Blog stellen, aber du kannst gerne auf den Code zugreifen von optimizar_cantidad.py

Anwendungsentwicklung:

Wir werden eine Preisoptimierungsanwendung mit Plotly Dash entwickeln, das ist ein Python-Framework zum Erstellen von Datenanwendungen. Lassen Sie uns eine Datei nach Namen erstellen app.py und starten Sie das Laden von Bibliotheken.

Paso 1: Bibliothek laden:

Bindestrich importieren
Pandas als pd importieren
numpy als np importieren
importiere dash_table
Protokollierung importieren
importiere plotly.graph_objs als go
importiere plotly.express als px
importiere dash_core_components als dcc
importiere dash_html_components als html
importiere dash_bootstrap_components als dbc
aus dash.dependencies import Input, Ausgabe, Bundesland
optimieren_preis importieren
optimieren_quantity importieren
importiere dash_daq als daq

Paso 2: Gestalten Sie das Layout:

Wir unterteilen das Design in 4 Abschnitte nebeneinander, wie wir im Intro-Schnappschuss gesehen haben.

Die Kontrollen / Felder, nämlich, der Schieberegler zur Auswahl maximal und minimal, Optionsfeld zum Auswählen Preis oder Menge optimieren, Texteingabe zum Konfigurieren Fixkosten.
Ein Diagramm zur Visualisierung der Beziehung zwischen Preis vs. Menge
Eine Grafik zur Visualisierung der optimales Einkommen
Ein Tisch mit simulierte Daten

Hier ist der UI-Code zum Generieren eines Bereichsschiebereglers.

html.Div(
	Klassenname="padding-top-bot",
	Kinder=[
		html.H6("OPTIMIERUNGSBEREICH"),
		html.Div(
			id='output-container-range-slider'),
		dcc.RangeSlider(
			id='my-range-slider',
			min = 0,
			max=500,
			Schritt=1,
			Markierungen={
				0: '0',
				500: '500'
			},
			Wert=[200, 400]
		),
	],
),

Es wird sehr nützlich sein, die vom Benutzer ausgewählten Maximal- und Minimalwerte anzuzeigen, und wir können dies mit einer Rückruffunktion erreichen.

@app.callback(
    Bindestrich.Abhängigkeiten.Ausgabe('Ausgabe-Container-Bereich-Schieberegler', 'Kinder'),
    [Bindestrich.Abhängigkeiten.Eingabe('mein-Bereich-Schieberegler', 'Wert')])
def update_output(Wert):
    Rückkehr "{}".Format(Wert)

Auf die gleiche Weise, wir werden noch zwei weitere Kontrollen hinzufügen. bitte beziehen Sie sich auf app.py für den kompletten Code.

Paso 3: Um Interaktivität zwischen Steuerelementen und Bildern aufzubauen, wir definieren die Ein- und Ausgänge, nämlich, für jede Änderung der Eingaben des Benutzers, Welche Ausgaben müssen aktualisiert werden?. In unserem Fall, wir müssen zwei Liniendiagramme und eine Tabelle aktualisieren.

@app.callback(
    [
        Ausgabe("Heatmap", 'Daten'),
        Ausgabe("Liniendiagramm1", 'Abbildung'),
        Ausgabe("lineChart2", 'Abbildung'),
        Ausgabe("id-einblicke", 'Kinder'), 
    ],
    [
        Eingang("select-var-opt", "Wert"),
        Eingang("my-range-slider", "Wert"),
        Eingang("Selected-Cost-Opt", "Wert")
    ])

Paso 4: Wir definieren a Funktion update_output_All () die die Steuerelemente als Eingaben verwendet, die Logik ausführen, was bedeutet, dass die Bilder und die Datentabelle generiert wurden, in der Benutzeroberfläche auszufüllen.

def update_output_All(var_opt, var_range, var_kosten):
    Versuchen:
        if var_opt == 'Preis':
            res, fig_PriceVsRevenue, fig_PreisVsMenge, opt_Preis, opt_Revenue = Python.optimize_price.fun_optimize(
                var_opt, var_range, var_kosten, df)
            res = np.rund(res.sort_values(
                'Einnahmen', aufsteigend=Falsch), Dezimalstellen=2)
            wenn opt_Revenue > 0:
                Rückkehr [res.to_dict('Aufzeichnungen'), fig_PriceVsRevenue, fig_PreisVsMenge, 
                    f'Der maximale Umsatz von {opt_Revenue} wird durch Optimierung erreicht {var_opt} von {opt_Preis}, Fixkosten von {var_kosten} und Optimierung wurde für {var_opt} Bereich zwischen {var_range}']
        ..................................
        ..................................
    außer Ausnahme als e:
        Protokollierung.Ausnahme("Mit der Interaktionslogik ist etwas schief gelaufen":', e)

bitte beziehen Sie sich auf app.py für den kompletten Code.

Empfehlungen: Obwohl wir eine sehr einfache Anwendung mit minimalen Feldern und Bildern erstellen, wir müssen noch die Eingabeauswahl überprüfen, beobachte die Muster, maximale Einkommenspunkte identifizieren und Schlussfolgerungen ziehen. Es wäre gut, Empfehlungen hinzuzufügen, bei denen uns die Anwendung sagt, ob wir Gewinne oder Verluste erzielen und uns auch die ausgewählten Parameter mitteilen.

Dies erreichen wir, indem wir dynamisch einen String aufbauen und die Platzhalter zur Laufzeit mit Werten füllen. Hier ist der Beispiel-Return-String unserer Callback-Funktion

f'Der maximale Umsatz von {opt_Revenue} wird durch Optimierung erreicht {var_opt} von {opt_Preis}, Fixkosten von {var_kosten} und Optimierung wurde für {var_opt} Bereich zwischen {var_range}']

Hier das Ergebnis der Musterempfehlung:

“Der Preis ist wirklich ganz einfach … Kunden zahlen buchstäblich keinen Cent mehr als den tatsächlichen Wert des Produkts”. – Ron Johnson

Wichtige Punkte, die Sie beachten sollten:

Wie Sie bemerkt haben, Der Aufbau einer modellgesteuerten Datenanwendung umfasst mehrere Phasen, und jede dieser Phasen birgt ihre eigenen Herausforderungen.

Datenqualität: Die Effizienz des ML-Modells hängt von der Qualität der Daten ab. Deswegen, Es ist wichtig, die Daten auf Abweichungen zu testen (Datendrift) des erwarteten Standards. Ein automatisierter Qualitätskontrollprozess hilft dabei, Anomalien in den Daten zu erkennen, und es müssen geeignete Schritte der Datenvorverarbeitung angewendet werden, um die Abweichung zu beheben..

Bau des Modells: Ein Model, ob einfach oder komplex, muss getestet werden, validiert und getestet, bevor sie für den Einsatz in der Produktion gepusht werden. Die Leistung des Modells in der Produktion sollte überwacht werden, zum Beispiel: Modellgröße, Reaktionszeit des Modells, Präzision, etc.

Einsatz: Das Modell wird im Allgemeinen als Dienst implementiert, den die Anwendung nutzt. und es muss eine nahtlose Integration verschiedener Komponenten geben, Datenquellen und andere Systeme. Viele Male, die Modelle sind für jede Region unterschiedlich, je nach den Anforderungen dieser Region, und dies führt zu mehreren Modellen, Modelldaten und Pipelines.

Modellüberwachung *: Wie jedes andere System, die implementierten Modelle sollten auch überwacht werden, um Abweichungen zu erkennen (Modellabweichung). Modelle werden umgeschult und in einer definierten Häufigkeit eingesetzt, das kann wöchentlich sein, monatlich oder vierteljährlich, je nach Art des Produkts / Service- und Geschäftsauswirkungen.

Notiz: Die Modellimplementierung wurde in diesem Blog nicht behandelt. Ich werde einen separaten Blog für die Anwendungsbereitstellung planen.

Schlussbemerkung:

Das Ziel des Blogs war es, einen sehr einfachen Ansatz zur Preisoptimierung vorzustellen und eine Webanwendung zu erstellen, die Geschäftsanwendern helfen kann, unterwegs Entscheidungen zu treffen.. Wir befassen uns auch mit verschiedenen Aspekten des Aufbaus einer Datenanwendung, von der Datenexploration bis zur Modellierung und den mit dem Erstellen verbundenen Herausforderungen., Implementierung und Wartung dieser Anwendung.

Diese Projektkonfiguration kann als Vorlage verwendet werden, um sie schnell für andere Anwendungsfälle zu replizieren.
Sie können ein komplexeres Modell erstellen, um jede Variable Ihres Interesses zu optimieren.
Verbinden Sie die Anwendung mit einer Datenbank und erstellen Sie CRUD-Operationen in der Anwendung.

Ich hoffe der Blog hat dir gefallen. Glückliche Ausbildungen !!!!

Du kannst dich mit mir verbinden – Linkedin

Sie können den Code als Referenz finden: Github