Я располагаю кодом, который симулирует игру сигналов между игроками (видеть код внизу). Игра состоит из 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 в настоящем коде ответа, если в Разделенном классе или в классе Игрок.