App per consigli sui prezzi con Python

Contenuti

“Nel momento in cui commetti un errore di prezzo, sta erodendo la tua reputazione o i tuoi profitti”. – Katharine Paine

L'ottimizzazione dei prezzi consiste nell'utilizzare i dati storici per identificare il prezzo più appropriato di un prodotto o servizio che massimizza la redditività dell'azienda. Ci sono numerosi fattori come la demografia, costi operativi, dati dell'indagine, eccetera. che svolgono un ruolo nella tariffazione efficiente, dipende anche dalla natura delle aziende e dal prodotto che viene servito. L'azienda aggiunge / aggiornare regolarmente le funzionalità per aggiungere più valore al prodotto e, ovviamente, questo ha un costo associato in termini di sforzo, tempo e, il più importante, la reputazione delle aziende.

Di conseguenza, è importante capire il prezzo corretto, un po' troppo alto, perderai i tuoi clienti e un leggero sottoprezzo si tradurrà in una perdita di entrate. L'ottimizzazione dei prezzi aiuta le aziende a trovare il giusto equilibrio tra prezzi efficienti, raggiungere obiettivi di profitto e servire anche i tuoi clienti. In questo blog, esamineremo l'approccio semplicistico all'ottimizzazione dei prezzi e creeremo anche un'applicazione di simulazione.

85709casa-9941683

Figura 1: Istantanea dell'app per consigli sui prezzi

Sfide nell'ottimizzazione dei prezzi:

Ottimizzazione del prezzo per un singolo prodotto: L'ottimizzazione del prezzo per un singolo prodotto prevede la modifica della domanda in risposta a prezzi diversi. Aiuta l'azienda a stabilire i prezzi che i clienti sono disposti a pagare e a massimizzare i profitti. Ad esempio: nel mercato degli smartphone, è un buon equilibrio tra nuove funzionalità e prezzo.

Ottimizzazione del prezzo per una famiglia di prodotti: Qualsiasi variazione del prezzo di un prodotto può innescare una reazione a catena in una famiglia di prodotti. Perciò, Il prezzo della famiglia di prodotti diventa un compito arduo. Non .: Al mercato del gelato, ci possono essere gusti diversi, taglie come in tazze, caramelle, coni, packs familiares o tarrinas. È lo stesso prodotto con dimensioni e prezzi diversi.

Vantaggi dell'ottimizzazione dei prezzi:

Vantaggi economici immediati: Las empresas pueden obtener resultados instantáneos al apuntar a múltiples KPI, o margen, conversioni di vendita, aggiungere nuovi clienti o entrare in un nuovo spazio di mercato, eccetera., e quindi rivedere i risultati per apportare le modifiche di prezzo appropriate.

Automazione dei processi aziendali: L'ottimizzazione dei prezzi dovrebbe essere più un processo basato sui dati. Analisi dei dati storici, tendenze di vendita, richiesta, eccetera. aiuta le aziende a progettare regole o creare modelli ML o creare un modello ibrido completamente automatizzato, eliminando così l'errore umano o le decisioni sui prezzi basate sulle emozioni.

Risposta rapida alle mutevoli tendenze del mercato: La domanda e l'andamento del mercato cambiano abbastanza frequentemente e, A volte, quando un concorrente lancia un prodotto simile a un prezzo inferiore, mangia le azioni degli altri. In uno scenario del genere, l'ottimizzazione dei prezzi dei prodotti in un particolare segmento di prodotto o area geografica aiuta le aziende ad affrontare questa sfida.

obiettivi:

Esploreremo i prossimi passi e, alla fine di questo blog, creeremo il App per il simulatore di ottimizzazione dei prezzi con sceneggiatura.

  • Panoramica sull'ottimizzazione dei prezzi
  • Sfide e vantaggi dell'ottimizzazione
  • Esplorazione dei dati
  • Costruzione e ottimizzazione del modello
  • Sviluppo di app con Plotly Dash
  • Sfide nella creazione e implementazione di modelli e applicazioni di ottimizzazione dei prezzi

Di partenza:

Dati: Useremo i dati dei giocattoli. Prezzo.csv ed ecco una rapida istantanea dei dati. Poiché il set di dati è piccolo e pulito, non è necessaria alcuna pre-elaborazione.

Anno Trimestre Quantità Prezzo          
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

Struttura del progetto: Ecco la struttura del nostro progetto.

Ottimizzazione del prezzo

| app.py # Il file per la creazione di app con logica di callback e interfaccia utente

+ -Risorse # Il foglio di stile che definisce l'estetica dell'applicazione.

|

+ -Dati

| prezzo.csv # Il file del set di dati

+ -Pitone

| optimizar_precio.py # Il file Python con la logica per l'ottimizzazione dei prezzi.

| optimizar_cantidad.py # Il file python con la logica per l'ottimizzazione della quantità

Caricamento librerie: Creiamo un file per nome optimizar_precio.py e carica tutte le librerie necessarie.

importa panda come pd
importa numpy come np
dai panda import DataFrame
importa matplotlib.pyplot come plt
import seaborn come sns
da statsmodels.formula.api import ols
import plotly.express come px
importa plotly.graph_objects come vai

Diamo un'occhiata alla relazione tra Prezzo e Quantità e ci aspettiamo di vedere un andamento lineare.

fig_PriceVsQuantity = px.scatter(

df, x="Prezzo", y ="Quantità", colore="Costo", linea di tendenza="vecchi")

fig_PriceVsQuantity.show()
42635prezzo/quantità-4126457

Figura 2: Prezzo Vs Quantità

Costruire un modello base: Nel nostro caso, costruiremo un modello OLS (Minimo quadrato ordinario) molto basico.

# adatta al modello OLS
modello = ols("Quantità ~ Prezzo", dati=df).in forma()

Gamma di ottimizzazione: Nella maggior parte dei casi, abbiamo un'idea approssimativa dei prezzi minimo e massimo in base all'esperienza passata. Come siamo in procinto di identificare il miglior prezzo, sarà un buon punto di partenza e lo perfezioneremo ulteriormente con più iterazioni.

  Prezzo = listino(gamma(var_range[0], var_range[1], 10))
    costo = int(var_cost)
    quantità = []
    Entrate = []
    per io in prezzo:
        domanda = modello.params[0] + (model.params[1] * io)
        quantità.append(richiesta)
        Entrate.append((i-costo) * richiesta)

Creeremo un data frame con il 3 Colonne dei prezzi, Reddito e Importo che ci consentiranno di accedere facilmente a questi valori durante la fase di sviluppo dell'applicazione.

profitto = pd.DataFrame({"Prezzo": Prezzo, "Reddito": Reddito, "Quantità": quantità})

max_val = profit.loc[(profitto['Reddito'] == profitto['Reddito'].max())]
64863tableraw-7182955

Grafico a linee de optimización: Ecco la funzione che prevediamo di avere in classifica.

  • Il grafico dovrebbe aggiornarsi in base alla selezione di una fascia di prezzo da parte dell'utente / quantità o forse un costo fisso.
  • Il grafico dovrebbe indicare il punto esatto in cui il reddito è più alto.
fig_PriceVsRevenue = go.Figure()
    fig_PriceVsRevenue.add_trace(vai.Disperso(
        x=profitto['Prezzo'], y=profitto['Reddito']))
    fig_PriceVsRevenue.add_annotation(x=int(max_val['Prezzo']), y=int(max_val['Reddito']),
                                      testo="Entrate massime",
                                      showarrow=Vero,
                                      punta di freccia=1)
    fig_PriceVsRevenue.update_layout(
        showlegend=Falso,
        xaxis_title="Prezzo",
        yaxis_title="Reddito")
    fig_PriceVsRevenue.add_vline(x=int(max_val['Prezzo']), larghezza_linea=2, line_dash="trattino",
                                 line_color="rosso", opacità=0.25)
28397max20revenue-3778606

Figura 3: Prezzo vs reddito

Mettere tutto insieme: La logica dell'ottimizzazione del prezzo sarà nel file. optimizar_precio.py

importa panda come pd
importa numpy come np
dai panda import DataFrame
importa matplotlib.pyplot come plt
import seaborn come sns
da statsmodels.formula.api import ols
import plotly.express come px
importa plotly.graph_objects come vai
def fun_optimize(var_opt, var_range, var_cost, df):
    fig_PriceVsQuantity = px.scatter(
        df, x="Prezzo", y ="Quantità", colore="Costo", linea di tendenza="vecchi")
    # adatta al modello OLS
    modello = ols("Quantità ~ Prezzo", dati=df).in forma()
    Prezzo = listino(gamma(var_range[0], var_range[1], 10))
    costo = int(var_cost)
    quantità = []
    ......................
    ......................

    Restituzione [profitto, fig_PriceVsRevenue, fig_PriceVsQuantity, il giro(max_val['Prezzo'].valori[0],2),il giro(max_val['Reddito'].valori[0],3)]

Ottimizzazione della quantità: Seguiremo un approccio simile per ottimizzare l'importo di una determinata restrizione per ottenere il massimo delle entrate.. Per brevità e affinchè il blog non sia esteso, Non metterò il codice nel blog, ma sentiti libero di accedere al codice da optimizar_cantidad.py

Sviluppo di applicazioni:

Svilupperemo un'applicazione per l'ottimizzazione dei prezzi con Plotly Dash, che è un framework Python per la creazione di applicazioni dati. Creiamo un file per nome app.py e inizia a caricare le librerie.

passo 1: carico della libreria:

importa il trattino
importa panda come pd
importa numpy come np
import dash_table
importazione registrazione
importa plotly.graph_objs come vai
import plotly.express come px
importa dash_core_components come dcc
importa dash_html_components come html
importa dash_bootstrap_components come dbc
da dash.dependencies import Input, Produzione, Stato
import Optimize_price
importa quantità_ottimizzata
importa dash_daq come daq

passo 2: Progetta il layout:

Dividiamo il design in 4 sezioni affiancate come abbiamo visto nell'istantanea introduttiva.

  1. I controlli / campi, vale a dire, il cursore per selezionare massimo e minimo, pulsante di opzione per selezionare Prezzo o quantità ottimizzare, input di testo da configurare costo fisso.
  2. Un grafico per visualizzare la relazione tra Prezzo Vs Quantità
  3. Un grafico per visualizzare il reddito ottimale
  4. Un tavolo che ha dati simulati

Ecco il codice dell'interfaccia utente per generare un dispositivo di scorrimento dell'intervallo.

html.Div(
	nomeclasse="imbottitura-top-bot",
	bambini=[
		html.H6("GAMMA DI OTTIMIZZAZIONE"),
		html.Div(
			id='output-contenitore-range-slider'),
		dcc.RangeSlider(
			id='il mio-cursore-intervallo',
			minimo = 0,
			massimo=500,
			passo=1,
			segni={
				0: '0',
				500: '500'
			},
			valore=[200, 400]
		),
	],
),

Sarà molto utile mostrare i valori massimo e minimo selezionati dall'utente e possiamo ottenere ciò con una funzione di callback.

@app.callback(
    dash.dipendenze.Output('slider-range-contenitore-uscita', 'figli'),
    [dash.dipendenze.Input('my-range-slider', 'valore')])
def update_output(valore):
    Restituzione "{}".formato(valore)

Nello stesso modo, aggiungeremo altri due controlli. per favore riferisci a app.py per il codice completo.

passo 3: Per creare interattività tra controlli e immagini, definiamo gli ingressi e le uscite, vale a dire, per ogni modifica degli input effettuata dall'utente, quali sono gli output che devono essere aggiornati. Nel nostro caso, dobbiamo aggiornare due grafici a linee e una tabella.

@app.callback(
    [
        Produzione("mappa di calore", 'dati'),
        Produzione("graficolinea1", 'figura'),
        Produzione("graficoline2", 'figura'),
        Produzione("id-insights", 'figli'), 
    ],
    [
        Ingresso("var-opt-selezionato", "valore"),
        Ingresso("my-range-slider", "valore"),
        Ingresso("selezionato-costo-opt", "valore")
    ])

passo 4: Definiamo a funzione update_output_All () che prende i controlli come input, eseguire la logica, il che significa che ha generato le immagini e la tabella dei dati, da compilare nell'interfaccia utente.

def update_output_All(var_opt, var_range, var_cost):
    Tentativo:
        if var_opt == 'prezzo':
            res, fig_PriceVsRevenue, fig_PriceVsQuantity, opt_Price, opt_Revenue = Python.optimize_price.fun_optimize(
                var_opt, var_range, var_cost, df)
            res = np.round(res.sort_values(
                'Reddito', ascendente=Falso), decimali=2)
            if opt_Revenue > 0:
                Restituzione [res.to_dict('record'), fig_PriceVsRevenue, fig_PriceVsQuantity, 
                    f'Il ricavo massimo di {opt_Revenue} si ottiene ottimizzando {var_opt} di {opt_Price}, costo fisso di {var_cost} e l'ottimizzazione è stata effettuata per {var_opt} intervallo tra {var_range}']
        ..................................
        ..................................
    tranne Eccezione come e:
        logging.eccezione('Qualcosa è andato storto con la logica di interazione:', e)

per favore riferisci a app.py per il codice completo.

consigli: Anche se stiamo creando un'applicazione molto semplice con campi e immagini minime, dobbiamo ancora controllare la selezione dell'input, osserva gli schemi, identificare i punti di reddito massimo e trarre conclusioni. Sería bueno agregar recomendaciones donde la aplicación nos diga si estamos obteniendo ganancias o pérdidas y también nos informe de los parametri seleccionados.

Logramos esto construyendo dinámicamente una cadena y llenando los Marcatori de posición con valores durante el tiempo de ejecución. Ecco la stringa di ritorno di esempio dalla nostra funzione di callback

f'Il ricavo massimo di {opt_Revenue} si ottiene ottimizzando {var_opt} di {opt_Price}, costo fisso di {var_cost} e l'ottimizzazione è stata effettuata per {var_opt} intervallo tra {var_range}']

Ecco il risultato della raccomandazione del campione:

76105raccomandazioni-9790720

“Il prezzo è davvero abbastanza semplice … I clienti non pagheranno letteralmente un centesimo in più rispetto al valore effettivo del prodotto”. – Ron Johnson

Punti chiave da tenere a mente:

Come avrai notato, Ci sono diverse fasi per la creazione di un'applicazione dati basata su modello e ciascuna di queste fasi comporta una serie di sfide.

Qualità dei dati: L'efficienza del modello ML dipende dalla qualità dei dati. Perciò, è importante testare i dati per eventuali deviazioni (deriva dei dati) dello standard previsto. Un processo di controllo della qualità automatizzato aiuta a identificare eventuali anomalie nei dati e devono essere applicate adeguate fasi di pre-elaborazione dei dati per correggere la deviazione..

Costruzione del modello: Un modello, che sia semplice o complesso, deve essere testato, convalidato e testato prima di essere spinto per l'uso in produzione. Le prestazioni del modello in produzione dovrebbero essere monitorate, ad esempio: dimensione del modello, tempo di risposta del modello, precisione, eccetera.

Distribuzione: Il modello è generalmente implementato come un servizio che l'applicazione consuma. e ci deve essere una perfetta integrazione di vari componenti, fonti di dati e altri sistemi. Molte volte, i modelli sono diversi per ogni regione in base alla domanda di quella geografia, e questo si traduce in più modelli, dati del modello e pipeline.

Monitoraggio del modello *: Come qualsiasi altro sistema, anche i modelli implementati dovrebbero essere monitorati per rilevare deviazioni (deviazione del modello). I modelli vengono riqualificati e distribuiti a una frequenza definita, che può essere settimanale, mensile o trimestrale, a seconda della natura del prodotto / servizio e impatto sul business.

Nota: L'implementazione del modello non è stata trattata come parte di questo blog. Pianificherò un blog separato dedicato alla distribuzione delle applicazioni.

Nota di chiusura:

L'obiettivo del blog era presentare un approccio molto semplicistico all'ottimizzazione dei prezzi e creare un'applicazione web che potesse aiutare gli utenti aziendali a prendere decisioni in movimento.. Affrontiamo anche vari aspetti della creazione di un'applicazione dati, dall'esplorazione dei dati alla modellazione e alle sfide associate alla costruzione., implementazione e mantenimento di detta applicazione.

  • Questa configurazione del progetto può essere utilizzata come modello per replicarla rapidamente per altri casi d'uso.
  • puede construir un modelo más complejo para optimizar cualquier variabile de su interés.
  • Conecte la aplicación a una Banca dati y cree operaciones CRUD en la aplicación.

Spero che il blog ti sia piaciuto. Buon Apprendistato !!!!

Puoi connetterti con me – Linkedin

Puoi trovare il codice di riferimento: Github

Riferimento:

https://dash.plotly.com/

https://dash.plotly.com/dash-daq

https://unsplash.com/

Il supporto mostrato in questo articolo non è di proprietà di DataPeaker e viene utilizzato a discrezione dell'autore.

Iscriviti alla nostra Newsletter

Non ti invieremo posta SPAM. Lo odiamo quanto te.