bytepeaker_logo
Envelope

Aplicación de recomendación de precios con Python

Contenidos

«En el momento en que comete un error en la fijación de precios, está mermando su reputación o sus ganancias». – Katharine Paine

La optimización de precios consiste en utilizar datos históricos para identificar el precio más apropiado de un producto o servicio que maximiza la rentabilidad de la empresa. Hay numerosos factores como la demografía, los costos operativos, los datos de la encuesta, etc. que juegan un papel en la fijación de precios eficiente, también depende de la naturaleza de las empresas y del producto que se sirve. La empresa agrega / actualiza regularmente funciones para aportar más valor al producto y, obviamente, esto tiene un costo asociado en términos de esfuerzo, tiempo y, lo más importante, la reputación de las empresas.

Como resultado, es importante comprender el precio correcto, un poco demasiado alto, perderá a sus clientes y un leve subprecio resultará en una pérdida de ingresos. La optimización de precios ayuda a las empresas a encontrar el equilibrio adecuado entre precios eficientes, lograr objetivos de ganancias y también atender a sus clientes. En este blog, veremos el enfoque simplista de optimización de precios y también crearemos una aplicación de simulación.

85709home-9941683

Figura 1: Instantánea de la aplicación de recomendación de precios

Desafíos en la optimización de precios:

Optimización de precios para un solo producto: La optimización de precios para un solo producto es predecir la demanda cambiante en respuesta a diferentes precios. Ayuda a la empresa a fijar los precios que los clientes están dispuestos a pagar y a maximizar las ganancias. Por ejemplo: en el mercado de los teléfonos inteligentes, es un buen equilibrio entre las nuevas funciones y el precio.

Optimización de precios para una familia de productos: Cualquier cambio en el precio de un producto puede desencadenar una reacción en cadena en una familia de productos. Por tanto, la fijación de precios de la familia de productos se convierte en una tarea abrumadora. Ej .: En el mercado de los helados, puede haber diferentes sabores, tamaños como en tazas, caramelos, conos, packs familiares o tarrinas. Es el mismo producto con diferentes tamaños y precios.

Beneficios de optimizar los precios:

Beneficios económicos inmediatos: Las empresas pueden obtener resultados instantáneos al apuntar a múltiples KPI, ya sea margen, conversiones de ventas, la adición de nuevos clientes o penetrar en un nuevo espacio de mercado, etc., y luego revisar los resultados para realizar los cambios adecuados en los precios.

Automatización de procesos comerciales: Las optimizaciones de precios deberían ser más un proceso basado en datos. El análisis de datos históricos, tendencias de ventas, demanda, etc. ayuda a las empresas a diseñar reglas o construir modelos de ML o construir un modelo híbrido que está completamente automatizado, eliminando así el error humano o las decisiones basadas en emociones sobre los precios.

Respuesta rápida a las tendencias cambiantes del mercado: La demanda y la tendencia del mercado cambian con bastante frecuencia y, a veces, cuando un competidor lanza un producto similar a un precio más bajo, se come las acciones de otros. En tal escenario, optimizar los precios de los productos en un segmento de producto o geografía en particular ayuda a las empresas a enfrentar este desafío.

Objetivos:

Exploraremos los siguientes pasos y, al final de este blog, crearemos el Aplicación Price Optimization Simulator con guión de trama.

  • Descripción general de la optimización de precios
  • Desafíos y beneficios de la optimización
  • Exploración de datos
  • Optimización y construcción de modelos
  • Desarrollo de aplicaciones con Plotly Dash
  • Desafíos en la creación e implementación de modelos y aplicaciones de optimización de precios

Empezando:

Datos: Usaremos datos de juguetes. Price.csv y aquí hay una instantánea rápida de los datos. Como el conjunto de datos es pequeño y limpio, no es necesario ningún tipo de procesamiento previo.

Year  Quarter	Quantity	Price          
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

Estructura del proyecto: Aquí está la estructura de nuestro proyecto.

Optimización de precios

| app.py # El archivo para la creación de aplicaciones que tiene lógica de devolución de llamada y UI

+ —Activos # La hoja de estilo que define la estética de la aplicación.

|

+ —Datos

| price.csv # El archivo del conjunto de datos

+ —Python

| optimizar_precio.py # El archivo Python con lógica para la optimización de precios.

| optimizar_cantidad.py # El archivo python con lógica para optimización de cantidad

Cargando Bibliotecas: Vamos a crear un archivo por nombre optimizar_precio.py y cargue todas las bibliotecas necesarias.

import pandas as pd
import numpy as np
from pandas import DataFrame
import matplotlib.pyplot as plt
import seaborn as sns
from statsmodels.formula.api import ols
import plotly.express as px
import plotly.graph_objects as go

Veamos la relación entre Precio y Cantidad y esperamos ver una tendencia lineal.

fig_PriceVsQuantity = px.scatter(

df, x="Price", y="Quantity", color="Cost", trendline="ols")

fig_PriceVsQuantity.show()
42635pricevsquantity-4126457

Figura 2: Precio Vs Cantidad

Construyendo un modelo básico: En nuestro caso, construiremos un modelo OLS (Ordinary Least Square) muy básico.

# fit OLS model
model = ols("Quantity ~ Price", data=df).fit()

Rango de optimización: En la mayoría de los casos, tenemos una idea aproximada de los precios mínimos y máximos basados ​​en la experiencia pasada. Como estamos en el proceso de identificar el mejor precio, será un buen punto de partida y lo refinaremos aún más con múltiples iteraciones.

  Price = list(range(var_range[0], var_range[1], 10))
    cost = int(var_cost)
    quantity = []
    Revenue = []
    for i in Price:
        demand = model.params[0] + (model.params[1] * i)
        quantity.append(demand)
        Revenue.append((i-cost) * demand)

Crearemos un marco de datos con las 3 columnas Precio, Ingresos y Cantidad que nos permitirá acceder fácilmente a estos valores durante la fase de desarrollo de la aplicación.

profit = pd.DataFrame({"Price": Price, "Revenue": Revenue, "Quantity": quantity})

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

Gráfico de líneas de optimización: Aquí está la característica que planearemos tener en el gráfico.

  • El gráfico debe actualizarse según la selección del usuario de un rango de precio / cantidad o tal vez un costo fijo.
  • El gráfico debe indicar el punto exacto donde los ingresos están al máximo.
fig_PriceVsRevenue = go.Figure()
    fig_PriceVsRevenue.add_trace(go.Scatter(
        x=profit['Price'], y=profit['Revenue']))
    fig_PriceVsRevenue.add_annotation(x=int(max_val['Price']), y=int(max_val['Revenue']),
                                      text="Maximum Revenue",
                                      showarrow=True,
                                      arrowhead=1)
    fig_PriceVsRevenue.update_layout(
        showlegend=False,
        xaxis_title="Price",
        yaxis_title="Revenue")
    fig_PriceVsRevenue.add_vline(x=int(max_val['Price']), line_width=2, line_dash="dash",
                                 line_color="red", opacity=0.25)
28397max20revenue-3778606

Figura 3: Precio Vs Ingresos

Poniendolo todo junto: La lógica de la optimización de precios estará en el archivo. optimizar_precio.py

import pandas as pd
import numpy as np
from pandas import DataFrame
import matplotlib.pyplot as plt
import seaborn as sns
from statsmodels.formula.api import ols
import plotly.express as px
import plotly.graph_objects as go
def fun_optimize(var_opt, var_range, var_cost, df):
    fig_PriceVsQuantity = px.scatter(
        df, x="Price", y="Quantity", color="Cost", trendline="ols")
    # fit OLS model
    model = ols("Quantity ~ Price", data=df).fit()
    Price = list(range(var_range[0], var_range[1], 10))
    cost = int(var_cost)
    quantity = []
    ......................
    ......................

    return [profit, fig_PriceVsRevenue, fig_PriceVsQuantity, round(max_val['Price'].values[0],2),round(max_val['Revenue'].values[0],3)]

Optimización por cantidad: Seguiremos un enfoque similar para optimizar la cantidad de una restricción determinada para obtener los máximos ingresos. En aras de la brevedad y para que el blog no sea extenso, no voy a colocar el código en el blog, pero no dudes en acceder al código desde optimizar_cantidad.py

Desarrollo de aplicaciones:

Desarrollaremos una aplicación de optimización de precios con Plotly Dash, que es un marco de Python para crear aplicaciones de datos. Creemos un archivo por nombre app.py y comience con la carga de bibliotecas.

Paso 1: carga de bibliotecas:

import dash
import pandas as pd
import numpy as np
import dash_table
import logging
import plotly.graph_objs as go
import plotly.express as px
import dash_core_components as dcc
import dash_html_components as html
import dash_bootstrap_components as dbc
from dash.dependencies import Input, Output, State
import optimize_price
import optimize_quantity
import dash_daq as daq

Paso 2: Diseñar el diseño:

Dividimos el diseño en 4 secciones una al lado de la otra como vimos en la instantánea de la introducción.

  1. Los controles / campos, a saber, el control deslizante para seleccionar máximo y mínimo, botón de radio para seleccionar Precio o cantidad para optimizar, entrada de texto para configurar costo fijo.
  2. Un gráfico para visualizar la relación entre Precio Vs Cantidad
  3. Un gráfico para visualizar el ingresos óptimos
  4. Una mesa que tiene datos simulados

Aquí está el código de la interfaz de usuario para generar un control deslizante de rango.

html.Div(
	className="padding-top-bot",
	children=[
		html.H6("OPTIMIZATION RANGE"),
		html.Div(
			id='output-container-range-slider'),
		dcc.RangeSlider(
			id='my-range-slider',
			min=0,
			max=500,
			step=1,
			marks={
				0: '0',
				500: '500'
			},
			value=[200, 400]
		),
	],
),

Será muy útil mostrar los valores de máximo y mínimo seleccionados por el usuario y podemos lograrlo con una función callback.

@app.callback(
    dash.dependencies.Output('output-container-range-slider', 'children'),
    [dash.dependencies.Input('my-range-slider', 'value')])
def update_output(value):
    return "{}".format(value)

Del mismo modo, agregaremos otros dos controles. por favor refiérase a app.py para el código completo.

Paso 3: Para construir la interactividad entre los controles y las imágenes, definimos las entradas y las salidas, es decir, para cada cambio en las entradas realizado por el usuario, que son las salidas que deben actualizarse. En nuestro caso, necesitamos actualizar dos gráficos de líneas y una tabla.

@app.callback(
    [
        Output("heatmap", 'data'),
        Output("lineChart1", 'figure'),
        Output("lineChart2", 'figure'),
        Output("id-insights", 'children'), 
    ],
    [
        Input("selected-var-opt", "value"),
        Input("my-range-slider", "value"),
        Input("selected-cost-opt", "value")
    ])

Paso 4: Definimos un función update_output_All () que toma los controles como entradas, ejecuta la lógica, lo que significa que generó las imágenes y la tabla de datos, que se completarán en la interfaz de usuario.

def update_output_All(var_opt, var_range, var_cost):
    try:
        if var_opt == 'price':
            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(
                'Revenue', ascending=False), decimals=2)
            if opt_Revenue > 0:
                return [res.to_dict('records'), fig_PriceVsRevenue, fig_PriceVsQuantity, 
                    f'The maximum revenue of {opt_Revenue} is achieved by optimizing {var_opt} of {opt_Price}, fixed cost of {var_cost} and optimization was carried for {var_opt} range between {var_range}']
        ..................................
        ..................................
    except Exception as e:
        logging.exception('Something went wrong with interaction logic:', e)

por favor refiérase a app.py para el código completo.

Recomendaciones: Aunque estamos creando una aplicación muy básica con campos y elementos visuales mínimos, aún necesitamos verificar la selección de entrada, observar los patrones, identificar los puntos de ingresos máximos y sacar conclusiones. 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 parámetros seleccionados.

Logramos esto construyendo dinámicamente una cadena y llenando los marcadores de posición con valores durante el tiempo de ejecución. Aquí está la cadena de retorno de muestra de nuestra función de devolución de llamada

f'The maximum revenue of {opt_Revenue} is achieved by optimizing {var_opt} of {opt_Price}, fixed cost of {var_cost} and optimization was carried for {var_opt} range between {var_range}']

Aquí está el resultado de la recomendación de muestra:

76105recommendations-9790720

«El precio es realmente bastante simple … Los clientes no pagarán literalmente un centavo más que el valor real del producto». – Ron Johnson

Puntos clave a tener en cuenta:

Como habrá notado, hay varias etapas para crear una aplicación de datos basada en modelos y cada una de estas etapas conlleva su propio conjunto de desafíos.

Calidad de los datos: La eficiencia del modelo ML depende de la calidad de los datos. Por lo tanto, es importante probar los datos para detectar cualquier desviación (desviación de los datos) del estándar esperado. Un proceso de control de calidad automatizado ayuda a identificar cualquier anomalía en los datos y se deben aplicar pasos adecuados de preprocesamiento de datos para rectificar la desviación.

Construcción del modelo: Un modelo, ya sea simple o complejo, necesita ser probado, validado y puesto a prueba antes de impulsarlo para su uso en producción. El desempeño del modelo en producción debe monitorearse, por ejemplo: tamaño del modelo, tiempo de respuesta del modelo, precisión, etc.

Despliegue: El modelo generalmente se implementa como un servicio que consume la aplicación. y tiene que haber una integración perfecta de varios componentes, fuentes de datos y otros sistemas. Muchas veces, los modelos son diferentes para cada región atendiendo a la demanda de esa geografía, y esto da como resultado múltiples modelos, datos y canalizaciones de modelos.

Supervisión del modelo *: Como cualquier otro sistema, los modelos implementados también deberán ser monitoreados para detectar desviaciones (desviación del modelo). Los modelos se vuelven a capacitar y se implementan con una frecuencia definida, que puede ser semanal, mensual o trimestral, según la naturaleza del producto / servicio y el impacto comercial.

Nota: La implementación del modelo no se cubrió como parte de este blog. Planearé un blog separado dedicado a la implementación de aplicaciones.

Nota de cierre:

El objetivo del blog era presentar un enfoque muy simplista para la optimización de precios y crear una aplicación web que pueda ayudar a los usuarios comerciales a tomar decisiones sobre la marcha. También abordamos varios aspectos de la creación de una aplicación de datos desde la exploración de datos hasta la creación de modelos y los desafíos asociados con la creación, implementación y mantenimiento de dicha aplicación.

  • Esta configuración de proyecto se puede utilizar como plantilla para replicarla rápidamente para otros casos de uso.
  • puede construir un modelo más complejo para optimizar cualquier variable de su interés.
  • Conecte la aplicación a una base de datos y cree operaciones CRUD en la aplicación.

Espero que les haya gustado el blog. ¡¡¡Felices Aprendizajes !!!!

Puedes conectarte conmigo – Linkedin

Puede encontrar el código como referencia: Github

Referencia:

https://dash.plotly.com/

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

https://unsplash.com/

Los medios que se muestran en este artículo no son propiedad de DataPeaker y se utilizan a discreción del autor.

Posts Relacionados:
  1. Sistema de recomendación de libros | Cree un sistema de recomendación de libros
  2. Análisis de precios de acciones con Python
  3. Cree un sistema de recomendación de películas por su cuenta
  4. Biblioteca de predicciones perezosas | Predicción de precios de vuelos mediante predicción diferida
Posteos recientes

Suscribite a nuestro Newsletter

No te enviaremos correo SPAM. Lo odiamos tanto como tú.

La data siempre al Peak

Twitter Facebook-f Youtube Medium

Gaming

Brands

Business

Idiomas