Mund-til-mund agent-baseret salgsmodel

Produktadoptionskurveestimering er et marketingdomæne, der kan drage fordel af agentbaseret modellering. Da jeg i øjeblikket arbejder på en agent-baseret modelleringsramme, ønskede jeg at tilføje en simpel mund-til-mund-agent-baseret produktsalgsmodel til denne blog . Modellen kan bruges som en simpel baseline for yderligere modifikationer (tilpasning). Jeg implementerer denne model i Python. Den af mig anvendte ramme kan findes her:

Link : abm_framework

Jeg har allerede delt to andre eksempler, der anvender ovenstående ramme. I det første eksempel udviklede jeg en agent-baseret SIR- model. Sådanne modeller kan fx bruges til at modellere sygdomsspredning.

Link : Agent-baseret SIR-model Python-eksempel

I et andet eksempel implementerede jeg en social segregationsmodel i Python.

Link : Agentbaseret adskillelsesmodel i Python

Jeg vil nu kort diskutere mund-til-mund-modellen og vise dens implementering i Python.

Simpel konceptuel mund-til-mund-model

Dette eksempel anvender et gitterbaseret simuleringsmiljø med en enkelt agentpopulation. Hver agent er karakteriseret ved en binær variabel. Variablen repræsenterer, om agenten allerede har købt det nye produkt (produktadoption) eller ej.

Følgende logik anvendes:

For hver iteration kaldes alle agenter én gang (i tilfældig rækkefølge)
Når en agent kaldes, vurderer agenten sit nabolag
Hvis agenten allerede har købt det nye produkt, bliver naboer påvirket af agenten og overbevist om at købe det nye produkt med en specificeret sandsynlighed. Eller omvendt, agenten er overbevist af enhver nabo, der allerede har købt produktet (med samme sandsynlighed)
Agenter kan kun købe produktet én gang. Når de har købt produktet, forbliver deres status uændret

Agent-baseret mund-til-mund-model i Python

Koden nedenfor anvender abm_framework og implementerer ovenstående mund-til-mund-model.

__author__ = "Linnart Felkl"
__email__ = "LinnartSF@gmail.com"

if __name__ == "__main__":

    print("demo starts")

    import sys
    from pathlib import Path
    file = Path(__file__).resolve()
    parent, root = file.parent, file.parents[1]
    sys.path.append(str(root))

    # remove the current file's directory from sys.path, unless already removed
    try:
        sys.path.remove(str(parent))
    except ValueError:
        pass

    import data
    import stats
    import config
    import framework
    import random
    import animation

    # setup database manager and connection
    db = data.Database("sqlite3", config.path_databasefile)
    db_manager = data.Manager(db)
    
    # create an empty environment
    env = framework.Environment(1, True, 20, 20, db_manager)

    # create initial of customers
    attrs = ["purchased"]
    datatypes = ["INTEGER"]
    pops = framework.Populations(amount = 1, env = env, db_manager = db_manager, attributes = attrs, datatypes = datatypes)
    pops.add_population(name = "customers", 
                        size = 100, 
                        attributes = attrs, 
                        datatypes = datatypes, 
                        initialvals = [0]
                        )
    
    # model specific global settings (parameter values)
    _prob_recommend = 0.03
    _impactarea = 2
    _initialclients = 1

    # setup simulation
    sim = framework.Simulation(200)

    # make sure that environment and agents tables in database are ready
    pops.write_env_to_db(sim.Iteration)
    pops.write_agents_to_db(sim.Iteration)
    
    agents = pops.get_agents()

    # set initial purchases 
    for _ in range(_initialclients):
        agent = random.choice(agents)
        agent.set_attr_value("purchased", 1)

    # execute simulation run; with centralized simulation control
    while sim.run():
        
        # select one random agent after the other
        random.shuffle(agents)
        for agent in agents:

            # get that agents neighbourhood
            neighbours = env.get_neighbourhood(agent, mode = "moore", radius = _impactarea)

            for neighbour in neighbours:
                
                if agent.get_attr_value("purchased") == 1 and neighbour.get_attr_value("purchased") == 0 and random.uniform(0,1) < _prob_recommend: neighbour.set_attr_value("purchased", 1)

                if agent.get_attr_value("purchased") == 0 and neighbour.get_attr_value("purchased") == 1 and random.uniform(0,1) < _prob_recommend: 
                    
                    agent.set_attr_value("purchased", 1)
                    break               
                
        # update results in database, for agents and for environment
        pops.write_agents_to_db(sim.Iteration)
        pops.write_density_to_db(sim.Iteration)
    
    # get dataframes with simulation results
    agents_df = db_manager.get_agentsdf()
    density_df = db_manager.get_densitydf()

    # visualize simulation data
    stats.set_fontsizes(8,10,12)

    stats.plot_avgattr_lines(["purchased"], agents_df)
    stats.save_plot("avgpurchasingshare")

    animation.animate_density(
        df = density_df,
        filename = "purchasinganimation",
        attr = "purchased",
        defaultsize = 50,
        color = "blue",
        tpf = 0.05
    )

    # end program
    db.close()
    print("demo ends")

Jeg diskuterer simuleringsresultaterne i det følgende afsnit.

Mund-til-mund-simuleringsresultater

Plottet under linje blev genereret af abm_framework og viser den samlede andel af kunder, der allerede har købt produktet. Med de givne modelindstillinger er markedet fuldt ud penetreret. Produktadoption følger en noget s-formet adoptionskurve. Dette er, hvad jeg ville have forventet af modelindstillingerne.

Nedenstående animation viser desuden produktadoption i hele nettet. Denne simulering startede med en enkelt agent. Det er derfor, produktadoptionen spreder sig derfra. Gitteret er uendeligt, hvilket betyder, at når du forlader gitteret på fx højre side, kommer du ind i gitteret på venstre side. Når du forlader gitteret på toppen, kommer du ind i gitteret nederst. Gitteret har ingen grænse.

Resultaterne vil afvige, når du justerer modelindstillinger og -betingelser. Resultater vil også blive påvirket af eventuelle yderligere mekanismer i modellen. Ved at bruge denne simple mund-til-mund-agent-baserede model kan du oprette din egen modificerede produktadoptionsmodel.

Afsluttende bemærkninger om mund-til-mund ABM-modellen

I denne artikel præsenterede jeg en anden anvendelse af abm_framework i Python. Rammen understøtter mindre grid-baseret agent-baseret modellering. Ved at bruge modellen var jeg i stand til at implementere en simpel baseline mund-til-mund agent-baseret model. Modellen viser, hvordan produktadoption følger en s-formet kurve, og hvordan markedet i dette tilfælde er fuldt penetreret efter nogen tid. Du kan bruge denne simple basismodel til at oprette din egen modificerede version. For eksempel kan du implementere en model med flere konkurrerende produkter. Eller du kan implementere en model med forskellige kundegrupper og en række forskellige brugeroplevelser.