java - commons - Estimando una probabilidad dada otras probabilidades de un previo

apache commons math 3.4 api download

Question

Tengo un montón de datos que llegan (llamadas a un callcenter automatizado) sobre si una persona compra o no un producto en particular, 1 para comprar, 0 para no comprar.

Quiero utilizar estos datos para crear una probabilidad estimada de que una persona compre un producto en particular, pero el problema es que es posible que deba hacerlo con relativamente pocos datos históricos sobre cuántas personas compraron / no compraron ese producto.

Un amigo recomendó que con la probabilidad bayesiana, usted puede "ayudar" a su estimación de probabilidad al generar una "distribución de probabilidad previa", esencialmente esta es información sobre lo que espera ver, antes de tomar en cuenta los datos reales.

Entonces, lo que me gustaría hacer es crear un método que tenga algo así como esta firma (Java):

double estimateProbability(double[] priorProbabilities, int buyCount, int noBuyCount);

priorProbabilities es una matriz de probabilidades que he visto para productos anteriores, que este método usaría para crear una distribución previa para esta probabilidad. buyCount y noBuyCount son los datos reales específicos de este producto, a partir de los cuales quiero estimar la probabilidad de que el usuario compre, dados los datos y el previo. Esto se devuelve del método como un doble.

No necesito una solución matemáticamente perfecta, solo algo que hará mejor que un uniforme o plano anterior (es decir, probabilidad = comprarCount / (buyCount + noBuyCount) ). Como estoy mucho más familiarizado con el código fuente que con la notación matemática, agradecería que las personas pudieran usar el código en su explicación.

Answer 1

Aquí está el cálculo bayesiano y un ejemplo / prueba:

def estimateProbability(priorProbs, buyCount, noBuyCount):
  # first, estimate the prob that the actual buy/nobuy counts would be observed
  # given each of the priors (times a constant that''s the same in each case and
  # not worth the effort of computing;-)`
  condProbs = [p**buyCount * (1.0-p)**noBuyCount for p in priorProbs]
  # the normalization factor for the above-mentioned neglected constant
  # can most easily be computed just once
  normalize = 1.0 / sum(condProbs)
  # so here''s the probability for each of the prior (starting from a uniform
  # metaprior)
  priorMeta = [normalize * cp for cp in condProbs]
  # so the result is the sum of prior probs weighed by prior metaprobs
  return sum(pm * pp for pm, pp in zip(priorMeta, priorProbs))

def example(numProspects=4):
  # the a priori prob of buying was either 0.3 or 0.7, how does it change
  # depending on how 4 prospects bought or didn''t?
  for bought in range(0, numProspects+1):
    result = estimateProbability([0.3, 0.7], bought, numProspects-bought)
    print ''b=%d, p=%.2f'' % (bought, result)

example()

salida es:

b=0, p=0.31
b=1, p=0.36
b=2, p=0.50
b=3, p=0.64
b=4, p=0.69

lo cual concuerda con mi cálculo manual para este caso simple. Tenga en cuenta que la probabilidad de comprar, por definición, siempre estará entre la más baja y la más alta entre el conjunto de probabilidades a priori; si eso no es lo que quieres, podrías introducir un poco de chocolate introduciendo dos "pseudoproductos", uno que nadie comprará nunca (p = 0.0), uno que cualquiera siempre comprará (p = 1.0) - esto da más peso a las observaciones reales, por pequeñas que sean, y menos a las estadísticas sobre productos pasados. Si hacemos eso aquí, obtenemos:

b=0, p=0.06
b=1, p=0.36
b=2, p=0.50
b=3, p=0.64
b=4, p=0.94

Los niveles intermedios de fudge (para tener en cuenta las posibilidades poco probables pero no imposibles de que este nuevo producto sea peor que cualquiera vendido previamente, o mejor que cualquiera de ellos) pueden ser fácilmente visualizados (otorgue menor peso a las probabilidades artificiales de 0.0 y 1.0) , agregando un vector priorWeights para estimateProbability los argumentos de Probability).

Este tipo de cosas es una parte sustancial de lo que hago todo el día, ahora que trabajo desarrollando aplicaciones en Business Intelligence, ¡pero no puedo tener suficiente ...! -)

Answer 2

Parece que lo que estás tratando de hacer es aprender la regla de asociación . No tengo tiempo en este momento para proporcionarle ningún código, pero lo señalaré en la dirección de WEKA, que es una fantástica herramienta de minería de datos de código abierto para Java. Deberías encontrar muchas cosas interesantes allí que te ayudarán a resolver tu problema.

Answer 3

Según lo veo, lo mejor que puedes hacer es usar la distribución uniforme, a menos que tengas alguna pista sobre la distribución. ¿O está hablando de establecer una relación entre estos productos y los productos previamente comprados por la misma persona en Amazon Fashion "las personas que compran este producto también compran ..."?

Answer 4

Una forma realmente simple de hacer esto sin cálculos matemáticos difíciles es aumentar buyCount y noBuyCount artificialmente agregando clientes virtuales que compraron o no compraron el producto. Puede ajustar cuánto cree en cada probabilidad previa particular en términos de cuántos clientes virtuales cree que valen.

En pseudocódigo:

def estimateProbability(priorProbs, buyCount, noBuyCount, faithInPrior=None):
    if faithInPrior is None: faithInPrior = [10 for x in buyCount]
    adjustedBuyCount = [b + p*f for b,p,f in 
                                zip(buyCount, priorProbs, faithInPrior]
    adjustedNoBuyCount = [n + (1-p)*f for n,p,f in 
                                zip(noBuyCount, priorProbs, faithInPrior]
    return [b/(b+n) for b,n in zip(adjustedBuyCount, adjustedNoBuyCount]