Подбирать x ты показываешь x симуляции

Следующий код производит CSV, в котором они являются серией колонн (ИГРОК, СИГНАЛ, RONDA1, RONDA2, RONDA3). В колоннах "RONDAx" появляются разы, что каждый игрок показал сигнал, определенный в каждом ночном обходе на протяжении 1000 симуляций игры (видеть for _ in range(1000)). Код конфигурировался для 3 ночных обходов и 4 игроков.

from random import random, sample
from bisect import bisect
import csv

class Partida():
    def __init__(self, jugadores, emparejamientos, senales, s, b, x, m):
        self.emparejamientos = emparejamientos
        self.senales = senales
        self.s = s
        self.b = b
        self.x = x
        self.m = m
        self.jugadores = {nombre: Partida.Jugador(senales)
                            for pareja in emparejamientos[0]
                                for nombre in pareja}
        self.memoria = list()


    def generar_senales(self):

        def with_b(muestra, observa, s, r):
            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 * s) + ((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 * s) + ((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.s[indx], r)
                            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, senales):
            self.mem_mostradas = {senal: 0 for senal in senales}
            self.men_observadas = {senal: 0 for senal in senales}



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)]]
    s=[1,0,0,0]
    b=0.5
    x=0.5
    m=0.02

    rondas = ['RONDA' + str(n+1) for n in range(len(emparejamientos))]
    estadisticas = {jugador:{senal:[0 for ronda in rondas]
                        for senal in senales}
                            for jugador in jugadores}

    for _ in range(1000):
        juego = Partida(jugadores, emparejamientos, senales, s, b, x, m)
        juego.jugar()
        for n, ronda in enumerate(juego.memoria):
            for jugador, senal in ronda.items():
                estadisticas[jugador][senal][n] += 1

    with open('salida.csv', 'wb') as csvfile:
        writer =csv.writer(csvfile, delimiter=',',
                    quotechar='"', quoting=csv.QUOTE_MINIMAL)
        writer.writerow(['JUGADOR', 'SENAL'] + rondas)

        for jugador in jugadores:
            for senal in senales:
                writer.writerow([jugador, senal]+estadisticas[jugador][senal])



if __name__ == '__main__':
    main()

Хочет использоваться сейчас этот же самый код, чтобы производить x образцы x симуляции и подбирать данные в CSV как в следующем примере: introducir la descripción de la imagen aquí

А именно, как он появляется, стремятся к тому, что код реализовал 3 раза 1000 симуляций полной игры, и что результаты 3 раз (3 образца) хранились, как он появляется в изображении. Где в "образце" номер "1" ссылается на первые 1000 симуляций, "2" ссылается на вторые 1000 симуляций и я схватил последовательно. Где "ночной обход" ссылается на число ночного обхода внутри игры. Где "игрок" ссылается на число игрока.

Ощутитесь, что в этот случай включаются параметры b, x и м в таблице, и что числа в колоннах "Senalx" должны ссылаться на разы, которые каждый сигнал был выбран в каждом ночном обходе.

1
задан 12.01.2017, 16:21
0 ответов

Делая какие-то изменения в функции main() ты можешь получать то, что ты хочешь (если я понял тебя bién). Просто мы изменяем структуру estadisticas для того, чтобы он хранил также переменную muestra и позже давайте верить csv с желанной структурой используя эти данные:

from random import random, sample
from bisect import bisect
import csv

class Partida():
    def __init__(self, jugadores, emparejamientos, senales, s, b, x, m):
        self.emparejamientos = emparejamientos
        self.senales = senales
        self.s = s
        self.b = b
        self.x = x
        self.m = m
        self.jugadores = {nombre: Partida.Jugador(senales)
                            for pareja in emparejamientos[0]
                                for nombre in pareja}
        self.memoria = list()


    def generar_senales(self):

        def with_b(muestra, observa, s, r):
            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 * s) + ((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 * s) + ((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.s[indx], r)
                            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, senales):
            self.mem_mostradas = {senal: 0 for senal in senales}
            self.men_observadas = {senal: 0 for senal in senales}



def main():
    jugadores = [1, 2, 3, 4]
    senales = ['Senal 1', 'Senal 2', 'Senal 3', 'Senal 4']
    emparejamientos = [[(1,2),(3,4)],
                       [(1,3),(2,4)],
                       [(1,4),(2,3)]]
    s=[1,0,0,0]
    b=0.5
    x=0.5
    m=0.02

    muestras = 3
    simulaciones = 1000

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


    for muestra in range(1, muestras+1):
        for _ in range(simulaciones):
            juego = Partida(jugadores, emparejamientos, senales, s, b, x, m)
            juego.jugar()
            for n, ronda in enumerate(juego.memoria):
                for jugador, senal in ronda.items():
                    estadisticas[jugador][muestra][senal][n] += 1

        with open('salida.csv', 'wb') as csvfile:
            writer =csv.writer(csvfile, delimiter=',',
                        quotechar='"', quoting=csv.QUOTE_MINIMAL)
            writer.writerow(['Muestra' ,'Jugador', 'Ronda', 'b', 'x', 'm'] + senales)

            for jugador in jugadores:
                for muestra in range(1, muestras+1):
                    for ronda in range(1, len(emparejamientos)+1):
                        aux = [estadisticas[jugador][muestra][senal][ronda-1] for senal in senales]
                        writer.writerow([muestra, jugador, ronda, b, x, m]+aux)


if __name__ == '__main__':
    main()

Это производит нам один csv формы:

introducir la descripción de la imagen aquí

Редактирование:

Если ты хочешь смочь перемещать его в каждый образец различную стоимость b, x и m ты можешь создавать список с ночными обходами и перемещать каждый набор параметров внутри списка, или лучше внутри словаря. Например, если у нас есть три ночных обхода, мы можем перемещать такую стоимость:

muestras = [{'b':0.2, 'x':0.5, 'm':0.02},
            {'b':0.4, 'x':0.6, 'm':0.02},
            {'b':0.5, 'x':0.7, 'm':0.02}]

Если в данном моменте ты хочешь, чтобы все параметры были равны, ты можешь делать что-то как:

muestras = [{'b':0.2, 'x':0.5, 'm':0.02} for _ in range(3)]

Что создало бы 3 ночных обхода, и все они считают стоимостью b, x и m 0.2,0.5 и 0.02 соответственно.

Код мог бы оставаться таким:

from random import random, sample
from bisect import bisect
import csv

class Partida():
    def __init__(self, jugadores, emparejamientos, senales, s, b, x, m):
        self.emparejamientos = emparejamientos
        self.senales = senales
        self.s = s
        self.b = b
        self.x = x
        self.m = m
        self.jugadores = {nombre: Partida.Jugador(senales)
                            for pareja in emparejamientos[0]
                                for nombre in pareja}
        self.memoria = list()


    def generar_senales(self):

        def with_b(muestra, observa, s, r):
            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 * s) + ((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 * s) + ((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.s[indx], r)
                            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, senales):
            self.mem_mostradas = {senal: 0 for senal in senales}
            self.men_observadas = {senal: 0 for senal in senales}



def main():
    jugadores = [1, 2, 3, 4]
    senales = ['Senal 1', 'Senal 2', 'Senal 3', 'Senal 4']
    emparejamientos = [[(1,2),(3,4)],
                       [(1,3),(2,4)],
                       [(1,4),(2,3)]]
    s=[1,0,0,0]

    muestras = [{'b':0.2, 'x':0.5, 'm':0.02},
                {'b':0.4, 'x':0.6, 'm':0.02},
                {'b':0.5, 'x':0.7, 'm':0.02}]


    simulaciones = 1000
    estadisticas = {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 mu in range(len(muestras)):
        for _ in range(simulaciones):
            juego = Partida(jugadores, emparejamientos, senales, s, 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[jugador][mu][senal][n] += 1

        with open('salidav4.csv', 'wb') as csvfile:
            writer =csv.writer(csvfile, delimiter=',',
                        quotechar='"', quoting=csv.QUOTE_MINIMAL)
            writer.writerow(['Muestra' ,'Jugador', 'Ronda', 'b', 'x', 'm'] + senales)

            for jugador in jugadores:
                for mu in range(len(muestras)):
                    for ronda in range(1, len(emparejamientos)+1):
                        aux = [estadisticas[jugador][mu][senal][ronda-1] for senal in senales]
                        writer.writerow([mu+1, jugador, ronda, muestras[mu]['b'], muestras[mu]['x'], muestras[mu]['m']]+aux)


if __name__ == '__main__':
    main()

То, что производит что-то нам как: introducir la descripción de la imagen aquí

Я думаю, что то, что ты желаешь, но проверь это на всякий случай.

1
ответ дан 03.12.2019, 17:42
  • 1
    ответ исключительный, как всегда. Это дает нам большие возможности, чтобы производить образцы и играть с pará метры. Иметь несколько образцов позволяет получать нормальное распределение, которое нужно сравнивать estadí sticamente. Я вижу, что ты касался только funció n main (магистерским способом это sí). Я представляю, что, если мы хотим получить в свою очередь 3 образца каждого словаря pará метры, только есть, что añ adir [for in range (3)] вслед за каждым словарем. Правда, что я está s помогая много и я изучаю montó n с тобой. –  12.01.2017, 19:56
  • 2
    Если только красилась funció n main (Разделенный класс не нужен изменять данная гибкость, которую нам предлагает POO). Если ты хочешь получить 3 образца каждого набора pará метры ты можешь делать: muestras = [{'b':0.2, 'x':0.5, 'm':0.02}, {'b':0.4, 'x':0.6, 'm':0.02}, {'b':0.5, 'x':0.7, 'm':0.02}] muestras = [d for d in muestras for _ in range(3)] Или следующее: muestras = [{'b':0.2, 'x':0.5, 'm':0.02}, {'b':0.4, 'x':0.6, 'm':0.02}, {'b':0.5, 'x':0.7, 'm':0.02}]*3 –  12.01.2017, 20:08
  • 3
    я осуществил возможность реализовывать симуляции с различными комбинациями изменчивая в. ¿ Ты можешь бросать глаз, чтобы видеть, правильно ли то, что я сделал? Я думаю, что в этой точке ты ú nico, что понимает сумасшествие, в которое мы идем помещенными :) –  14.01.2017, 18:31

Беря последнюю версию кода, я осуществлял новую возможность. Будет наблюдаться, что переменная s (что ссылается во что-то подобное на действительную стоимость каждого сигнала, и что имеется в виду в уравнении, вычислив вероятность, с которой каждый сигнал будет выбран в следующем поколении), до настоящего времени высказывалось как установленный список:

s= [1,0,0,0] #El valor de la "señal 1" es 1, de la "señal 2" 0, de la "señal 3" 0 y de la "señal 4" 0.

Хорошо, так как я осуществил возможность того, чтобы стоимость сигналов смогла чередоваться, и мы смогли реализовывать x симуляции для каждой комбинации внутренне присущей стоимости в. Я коснулся только функции _init_ и функция def main(), чтобы получать CSV с печатью результатов.

Здесь - код:

from random import random, sample
from bisect import bisect
import csv

class Partida():
    def __init__(self, jugadores, emparejamientos, senales, s1,s2,s3,s4, b, x, m):
        self.emparejamientos = emparejamientos
        self.senales = senales
        self.s = [s1,s2,s3,s4]
        self.b = b
        self.x = x
        self.m = m
        self.jugadores = {nombre: Partida.Jugador(senales)
                            for pareja in emparejamientos[0]
                                for nombre in pareja}
        self.memoria = list()


    def generar_senales(self):

        def with_b(muestra, observa, s, r):
            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 * s) + ((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 * s) + ((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.s[indx], r)
                            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, senales):
            self.mem_mostradas = {senal: 0 for senal in senales}
            self.men_observadas = {senal: 0 for senal in senales}



def main():
    jugadores = [1, 2, 3, 4]
    senales = ['Senal 1', 'Senal 2', 'Senal 3', 'Senal 4']
    emparejamientos = [[(1, 2), (3, 4)],
                       [(1, 3), (2, 4)],
                       [(1, 4), (2, 3)]]

    patron=1
    sm = [{'s1': 1, 's2': 0, 's3': 0, 's4': 0},
         {'s1': 0, 's2': 1, 's3': 0, 's4': 0},
         {'s1': 0, 's2': 0, 's3': 1, 's4': 0},
         {'s1': 0, 's2': 0, 's3': 0, 's4': 1}]
    sm = [d for d in sm for _ in range (10)]

    muestras = [{'b': 0.0, 'x': 0.0, 'm': 0.02},
                {'b': 0.5, 'x': 0.5, 'm': 0.02},
                {'b': 1.0, 'x': 1.0, 'm': 0.02}]
    muestras = [d for d in muestras for _ in range(10)]

    simulaciones = 10

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


    for su in range(len(sm)):
        for mu in range(len(muestras)):
            for _ in range(simulaciones):
                juego = Partida(jugadores, emparejamientos, senales, sm[su]['s1'], sm[su]['s2'],sm[su]['s3'],sm[su]['s4'], 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[jugador][su][mu][senal][n] += 1

        with open('practica2.csv', 'wb') as csvfile:
            writer =csv.writer(csvfile, delimiter=';',
                        quotechar='"', quoting=csv.QUOTE_MINIMAL)
            writer.writerow(['Muestra', 'Jugador', 'Ronda', 'Patron','s1','s2','s3','s4', 'b', 'x', 'm'] + senales)

            for jugador in jugadores:
                for su in range(len(sm)):
                    for mu in range(len(muestras)):
                        for ronda in range(1, len(emparejamientos)+1):
                            aux = [estadisticas[jugador][su][mu][senal][ronda-1] for senal in senales]
                            writer.writerow([mu+1, jugador, ronda, patron, sm[su]['s1'], sm[su]['s2'],sm[su]['s3'],sm[su]['s4'], muestras[mu]['b'], muestras[mu]['x'], muestras[mu]['m']]+aux)


if __name__ == '__main__':
    main()

Мне хотелось бы знать, эти осуществления, которые я реализовал в коде, - правильны ли.

Редактирование:

Adicionalmente, что уже кажется мне более сложным думать, как решать, давайте представлять, что мы хотим получить результаты игры (наша игра сейчас позволяет получать x образцы x симуляции для каждой желанной комбинации параметров) для двух различных главных файлов в порядке соединений попарно. Например, главный файл A соединений попарно с главным файлом B соединений попарно:

patronA_emparejamientos =[[(1, 2), (3, 4)],
                         [(1, 3), (2, 4)],
                         [(1, 4), (2, 3)]]

patronB_emparejamientos =[[(1, 3), (2, 4)],
                         [(1, 4), (2, 3)],
                         [(1, 2), (3, 4)]]

Это сейчас мы можем делать это с нашей программой реализовывая 2 симуляции независимо, одна для типа соединений попарно A и другая для типа соединений попарно B, и потом сочетая файлы csv. Но он не прекращает оказываться перегруженным.

Какая-то идея для того, чтобы программа мы возможности получать в том же файле csv результаты обоих главных файлов соединения попарно?

0
ответ дан 03.12.2019, 17:42

Теги

Похожие вопросы