Изменять список динамического способа для каждой группы элементов в игре iterativo

Я располагаю кодом, который симулирует игру сигналов между игроками (видеть код внизу). Игра состоит из 4 игроков и 4 сигналов, которые играют в парах в течение 3 ночных обходов (видеть def main()).

Определенные также в main(), существуют в игре переменные s1 и s2 (давайте называть их sigmas) что затрагивают динамику игры. Таким образом что в def with_b переменная s1 затронь уравнение, которое используют игроки 1 и 2, и переменная s2 затронь уравнение, которое используют игроки 3 и 4.

Эти переменные s1 и s2 они пребывают постоянными на протяжении игры, как будь сейчас: s1=[1,0,0,0] и s2=[0,0,0,1]

В игре, для каждый ronda, каждый jugador произведи список aux что представляет произведенный сигнал. Так, каждый ночной обход, каждый игрок произведет Ваш aux, что сможет быть одной из следующих: [1,0,0,0] или [0,1,0,0] или [0,0,1,0] или [0,0,0,1].

Цель

Давайте верить в два новых списка: s_inicial_1 и s_inicial_2.

То, к чему стремятся сейчас, что, для каждого ночного обхода и игрока, если Ваш aux совпади со списком s_inicial (s_inicial_1 в случае игроков 1 и 2, s_inicial_2 в случае игроков 3 и 4), была изменена стоимость Вашего sigma s1 или s2 внутри игры для этого конкретного игрока как facotres исправления.

Например. Если в определенном ночном обходе игрок производит 1 aux1=[1,0,0,0], ввиду того, что она готова, совпади с s_inicial_1=[1,0,0,0], стоимость s1 он умножится из-за cf_pos. Таким образом новая обновленная стоимость s1 он произведет для игрока 1 в функции def with_b. Если наоборот, игрок производит 1 aux1=[0,0,1,0], ввиду того, что она готова, он не совпадает с s_inicial_1=[1,0,0,0], стоимость s1 (для этого игрока) он умножится из-за cf_neg. Стоимость s1 или s2 каждого игрока они будут становиться отвечающими современным требованиям суммарно патрулируй в ночной обход.

s1 = [1,0,0,0]
s_inicial_1 = [1,0,0,0]
s2 = [0,0,0,1]
s_inicial_2 = [0,0,0,1]
cf_pos = 0.9
cf_neg = 0.1

Для игрока 1:

if aux1 == s_inicial_1:
    s1[:] = [x * cf_pos for x in s1]
else:
    s1[:] = [x * cf_neg for x in s1]

Для игрока 2:

if aux2 == s_inicial_1:
    s1[:] = [x * cf_pos for x in s1]
else:
    s1[:] = [x * cf_neg for x in s1]

Для игрока 3:

if aux3 == s_inicial_2:
    s2[:] = [x * cf_pos for x in s2]
else:
    s2[:] = [x * cf_neg for x in s2]

Для игрока 4:

if aux4 == s_inicial_2:
    s2[:] = [x * cf_pos for x in s2]
else:
    s2[:] = [x * cf_neg for x in s2]

Проблема, которую я наблюдаю, чем в настоящем коде aux я произвожу ее, написав файл csv не в игре в себе. Также, чем в существо s1 и s2 постоянные переменные, я не знаю, как он мог бы менять их dinámicamente (ночного обхода в ночном обходе) для каждого игрока без того, чтобы это меняло также Вашу стоимость sigma для оставшейся части игроков. Давайте говорить, что каждый был бы должен эволюционировать Ваш sigma независимо.

Большое спасибо заранее.

from __future__ import division
from random import random, sample
from bisect import bisect
from collections import deque
import csv
import math

    s_inicial_1 = [1,0,0,0]
    s_inicial_2 = [0,0,0,1]

    class Partida():
        def __init__(self, jugadores, menLen, emparejamientos, senales, s1, s2, b, x, m):
            self.emparejamientos = emparejamientos
            self.senales = senales
            self.s1 = s1
            self.s2 = s2
            self.b = b
            self.x = x
            self.m = m
            self.jugadores=jugadores
            self.jugadores = {nombre: Partida.Jugador(menLen)
                           for emparejamiento in emparejamientos[0]
                           for nombre in emparejamientos}
            self.memoria = list()
            self.entropy = float()

        def generar_senales(self):

            def with_b(muestra, observa, s1, s2, r, nombre):
                if nombre <=2:
                    if not (muestra == observa == 0):
                        result = ((0.98) * (1.0 - self.b) * (1.0 - self.x) * muestra / r) + (
                        (0.98) * (1.0 - self.b) * (self.x) * observa / r) + ((0.98) * self.b * s1) + ((self.m / 8))
                    else:
                        result = ((0.98) * (1.0 - 0) * (1.0 - self.x) * muestra / r) + (
                        (0.98) * (1.0 - 0) * (self.x) * observa / r) + ((0.98) * 0 * s1) + ((self.m / 8))
                else:
                    if not (muestra == observa == 0):
                        result = ((0.98) * (1.0 - self.b) * (1.0 - self.x) * muestra / r) + (
                        (0.98) * (1.0 - self.b) * (self.x) * observa / r) + ((0.98) * self.b * s2) + ((self.m / 8))
                    else:
                        result = ((0.98) * (1.0 - 0) * (1.0 - self.x) * muestra / r) + (
                        (0.98) * (1.0 - 0) * (self.x) * observa / r) + ((0.98) * 0 * s2) + ((self.m / 8))
                return result

            def choice(opciones, probs):
                probAcumuladas = list()
                aux = 0
                for p in probs:
                    aux += p
                    probAcumuladas.append(aux)
                r = random() * probAcumuladas[-1]
                op = bisect(probAcumuladas, r)
                return opciones[op]

            yield dict(zip(self.jugadores.keys(), self.senales))

            r = 1
            while True:
                eleccs = dict.fromkeys(self.jugadores.keys())
                for nombre, inst in self.jugadores.items():
                    probs = [with_b(inst.mem_mostradas[op], inst.men_observadas[op], self.s1[indx],self.s2[indx], r, nombre)
                             for indx, op in enumerate(self.senales)]
                    eleccs[nombre] = choice(self.senales, probs)
                r += 1
                yield eleccs

        def jugar(self):
            gen_sens = self.generar_senales()
            for n, ronda in enumerate(self.emparejamientos):
                senales = next(gen_sens)
                self.memoria.append(senales)

                for jugador1, jugador2 in ronda:
                    self.jugadores[jugador1].men_observadas[senales[jugador2]] += 1
                    self.jugadores[jugador2].men_observadas[senales[jugador1]] += 1
                    self.jugadores[jugador1].mem_mostradas[senales[jugador1]] += 1
                    self.jugadores[jugador2].mem_mostradas[senales[jugador2]] += 1


        class Jugador():
            def __init__(self, menLen):
                 self.mem_mostradas = deque(maxlen=menLen)
                 self.men_observadas = deque(maxlen=menLen)


    def main():
        jugadores = [1, 2, 3, 4]
        senales = ['S1', 'S2', 'S3', 'S4']
        emparejamientos = [[(1, 2), (3, 4)],
                           [(1, 3), (2, 4)],
                           [(1, 4), (2, 3)]]

        patron = 1
        menLen = 2

        ####SIGMAS####
        s1 = [1, 0, 0, 0]
        s2 = [0, 0, 0, 1]

        muestras = [{'b': 0.0, 'x': 0.5, 'm': 0.02}]

        muestras = [d for d in muestras for _ in range(1)]

        simulaciones = 10

        estadisticas = {sim: {jugador: {muestra: {senal: [0 for ronda in range(1, len(emparejamientos) + 1)]
                                            for senal in senales}
                                  for muestra in range(len(muestras))}
                        for jugador in jugadores}
                    for sim in range(simulaciones)}

        for sim in range(simulaciones):
            for mu in range(len(muestras)):
                juego = Partida(jugadores, menLen, emparejamientos, senales, s1,s2, muestras[mu]['b'], muestras[mu]['x'],
                                muestras[mu]['m'])
                juego.jugar()
                for n, ronda in enumerate(juego.memoria):
                    for jugador, senal in ronda.items():
                        estadisticas[sim][jugador][mu][senal][n] += 1

        with open('datos.csv','w', newline='') as csvfile:
                writer = csv.writer(csvfile, delimiter=';',
                                    quotechar='"', quoting=csv.QUOTE_MINIMAL)
                writer.writerow(['Sim','Muestra', 'Jugador', 'Ronda', 'Patron', 'b', 'x', 'm'] + senales + ['sumpop'])
     # Escribiendo las estadisticas para cada jugador, ronda y muestra
                for jugador in jugadores:
                    for sim in range(simulaciones):
                        for mu in range(len(muestras)):
                            for ronda in range(1, len(emparejamientos) + 1):
                                aux = [estadisticas[sim][jugador][mu][senal][ronda - 1] for senal in senales]
                                aux1 = [estadisticas[sim][1][mu][senal][ronda - 1] for senal in senales]
                                aux2 = [estadisticas[sim][2][mu][senal][ronda - 1] for senal in senales]
                                aux3 = [estadisticas[sim][3][mu][senal][ronda - 1] for senal in senales]
                                aux4 = [estadisticas[sim][4][mu][senal][ronda - 1] for senal in senales]
                                print(aux)
    # Lista que contiene los sumatorios de cada tipo de senales producidas a nivel de la poblacion global en cada muestra y ronda
                                summation_pop = []
                                for i in range(len(aux1)):
                                    summation_pop.append(
                                        aux1[i] + aux2[i] + aux3[i] + aux4[i])
                                writer.writerow([sim +1, mu + 1, jugador, ronda, patron, muestras[mu]['b'], muestras[mu]['x'],
                                             muestras[mu]['m']] + aux + [summation_pop])

    if __name__ == '__main__':
        main()

Редактирование кода (27.06.2019, 21:19 gtm +00)

  • Редактирование кода. Упрощается переменная muestras чтобы облегчать чтение данных. Стоимость {'b': 0.0, 'x': 0.5, 'm': 0.02} они позволяют больше изменение в outcome aux, так как уравнение, осуществленное в def with_b смоделируй сносу.
  • Для тестов: если 'b': 1.0 и s1 = [1,0,0,0] существует высокая вероятность того, что игроки произведут 1 и 2 aux = [1,0,0,0]. Если 'b': 0.0, существует больше вероятности того, что игроки произведут различный aux.

Конечное обновление

  • Ответ обсуждается удовлетворительно и распределенное вознаграждение. В этом добавочном замечании мне хотелось бы добавлять, что первоначальный код, который я имел здесь, не включал добавочную функциональность, которую он считал осуществленной в моем старом коде: возможность ограничивать размер памяти агентов определенным числом ночных обходов посредством переменной memLen. Точное осуществление загружать книжный магазин from collections import deque. Я издал код, предоставляемый в вопросе. Изменив столько вещей, я осведомлялся, каковым был бы лучший способ осуществлять сходный funconalidad в настоящем коде ответа, если в Разделенном классе или в классе Игрок.
7
задан 01.07.2019, 02:19
0 ответов