Beispiel #1
0
func Run(conf Config) error {
	rand.Seed(time.Now().UTC().UnixNano())

	fmt.Println("Loading proteins...")
	id, start, end, err := db.GetProteins(conf.DB)
	if err != nil {
		panic(err)
	}

	fmt.Println("Initializing probabilities...")
	r, _ := rules.Create(conf.CA.InitStates, conf.CA.TransStates, conf.CA.HasJoker, conf.CA.R)
	probs := NewProbs(r.Prm)

	var pop Population

	pop.rule = make([]*rules.Rule, conf.Design.Population)
	pop.fitness = make([]float64, conf.Design.Population)

	pop.rule[0], _ = rules.Create(conf.CA.InitStates, conf.CA.TransStates, conf.CA.HasJoker, conf.CA.R)
	cellauto, _ := ca.Create1D(id, start, end, pop.rule[0], conf.CA.Steps, conf.CA.Consensus)
	pop.fitness[0] = Fitness(cellauto)

	for i := 1; i < conf.Design.Population; i++ {

		pop.rule[i] = probs.GenRule()
		cellauto.SetRule(pop.rule[i])
		pop.fitness[i] = Fitness(cellauto)

	}

	pop.save("")

	return nil
}
Beispiel #2
0
func TestCreate1D(t *testing.T) {
	// teste caso 1
	id := tests[0].id
	begin := tests[0].begin
	end := tests[0].expected
	rule, _ := rules.Create(begin, end, true, 3)
	ca, err := Create1D(id, begin, end, rule, 10)
	if err != nil {
		t.Error("Caso 1. Erro na criação do autômato celular")
	}
	if ca == nil {
		t.Error("Caso 1. Erro no retorno do autômato celular")
	}

	// teste caso 2
	id = tests[1].id
	begin = tests[1].begin
	end = tests[1].expected
	rule, _ = rules.Create(begin, end, true, 3)
	ca, err = Create1D(id, begin, end, rule, 19)
	if err == nil {
		t.Error("Caso 2. Erro na criação do autômato celular que não capturou o erro. ")
	}
	if ca != nil {
		t.Error("Caso 2. Erro no retorno do autômato celular que retornou um autômato inválido")
	}

}
Beispiel #3
0
func TestGenRule(t *testing.T) {
	rule, _ := rules.Create(rules.PrmDefault)
	p := NewProbs(rule.Prm)
	ruleNew1 := p.GenRule()
	ruleNew2 := p.GenRule()
	fmt.Println("@@@Nova regra (1)", ruleNew1)
	fmt.Println("@@@Nova regra (2)", ruleNew2)
}
Beispiel #4
0
// func Run(selby string, fnrulein string, fnruleout string, fnprobout string, gen int, pop int, steps int, ca *ca.CellAuto1D, prm rules.Params) error {
func Run(conf Config) error {
	rand.Seed(time.Now().UTC().UnixNano())

	fmt.Println("Loading proteins...")
	id, start, end, err := db.GetProteins(conf.DB)
	if err != nil {
		panic(err)
	}

	fmt.Println("Initializing probabilities...")
	rule, _ := rules.Create(conf.CA.InitStates, conf.CA.TransStates, conf.CA.HasJoker, conf.CA.R)
	probs := NewProbs(rule.Prm)
	fmt.Println(probs)

	var calist []*ca.CellAuto1D

	calist = make([]*ca.CellAuto1D, conf.CGA.Selection)

	for i := 0; i < len(calist); i++ {
		r := probs.GenRule()
		calist[i], _ = ca.Create1D(id, start, end, r, conf.CA.Steps, conf.CA.Consensus)
	}

	var wg1 sync.WaitGroup
	for i := 0; i < conf.CGA.Generations; i++ {
		fmt.Println("Generation", i)
		fmt.Println("Adjusting probabilities...")
		probs.AdjustByRanking(calist, 1.0/float64(conf.CGA.Population))
		fmt.Println("OK")

		if probs.Converged() {
			fmt.Println("Probabilities converged\nDONE")
			break
		}

		for i := 0; i < len(calist); i++ {
			wg1.Add(1)
			go func(i int) {
				defer wg1.Done()
				calist[i].SetRule(probs.GenRule())
			}(i)
			// calist[i], _ = ca.Create1D(id, start, end, r, conf.CA.Steps)
		}
		fmt.Printf("Waiting ")
		wg1.Wait()
		fmt.Println("OK")
	}

	err = ioutil.WriteFile(conf.CGA.OutputProbs, []byte(probs.String()), 0644)
	if err != nil {
		fmt.Println("Erro gravar as probabilidades")
		fmt.Println(probs)
	}

	return nil
}
Beispiel #5
0
func Run(conf Config) error {
	rand.Seed(time.Now().UTC().UnixNano())

	fmt.Println("Loading proteins...")
	id, start, end, err := proteindb.GetProteins(conf.ProteinDB)
	if err != nil {
		panic(err)
	}

	fmt.Println("Initializing simulated annealing")
	rule, _ := rules.Create(conf.CA.InitStates, conf.CA.TransStates, conf.CA.HasJoker, conf.CA.R)
	cellauto, _ := ca.Create1D(id, start, end, rule, conf.CA.Steps, conf.CA.Consensus)

	solution := &Solution{rule, Fitness(cellauto)}
	solution_new := &Solution{rule, Fitness(cellauto)}
	solution_best := &Solution{rule, Fitness(cellauto)}

	alpha := math.Pow((conf.SA.Tfinal / conf.SA.Tini), 1.0/float64(conf.SA.OuterLoop))

	temp := conf.SA.Tini

	for outer := 0; outer < conf.SA.OuterLoop; outer++ {
		fmt.Println("@ Temperature", temp)
		for inner := 0; inner < conf.SA.InnerLoop; inner++ {
			solution_new.Neighbor(solution)
			cellauto.SetRule(solution_new.rule)
			solution_new.fitness = Fitness(cellauto)
			if solution_new.fitness >= solution.fitness {
				fmt.Println("Update", solution.fitness, "->", solution_new.fitness)
				solution.rule = solution_new.rule
				solution.fitness = solution_new.fitness
				//fmt.Println("Check update", solution.fitness, "=", solution_new.fitness)
				if solution.fitness > solution_best.fitness {
					fmt.Println("Update BEST", solution_best.fitness, "->", solution.fitness)
					solution_best.rule = solution.rule
					solution_best.fitness = solution.fitness
				}
			} else if math.Exp(solution_new.fitness-solution.fitness/temp) > rand.Float64() {

				fmt.Println("*Update", solution.fitness, "->", solution_new.fitness)
				solution.rule = solution_new.rule
				solution.fitness = solution_new.fitness
				//fmt.Println("*Check update", solution.fitness, "=", solution_new.fitness)
			}
		}
		temp = alpha * temp
	}

	err = ioutil.WriteFile(conf.Rules.Output, []byte(solution_best.rule.String()), 0644)
	if err != nil {
		fmt.Println("Erro gravar a melhor regra")
		fmt.Println(solution_best.rule)
	}
	fmt.Println("Melhor regra", solution_best.fitness)
	return nil
}
Beispiel #6
0
func TestAdjustByDuel(t *testing.T) {
	rule, _ := rules.Create(rules.PrmDefault)
	p := NewProbs(rule.Prm)
	fmt.Println(p)
	r1 := p.GenRule()
	r2 := p.GenRule()
	p.AdjustByDuel(r1, r2)
	for i := 0; i < 1000; i++ {
		r1 = p.GenRule()
		r2 = p.GenRule()
		p.AdjustByDuel(r1, r2)
		fmt.Println("Geração ", i)
		fmt.Println(p)
	}
}
Beispiel #7
0
func RunSlave(conf Config) {

	// Cria o receptor que recebe a probabilidade emitida pelo master na porta A
	receiver, _ := zmq.NewSocket(zmq.PULL)
	defer receiver.Close()
	receiver.Connect("tcp://" + conf.Dist.MasterURL + ":" + conf.Dist.PortA)

	// Cria o emissor que envia o individuo vencedor do torneio na rede pela
	// porta B
	sender, _ := zmq.NewSocket(zmq.PUSH)
	defer sender.Close()
	sender.Connect("tcp://" + conf.Dist.MasterURL + ":" + conf.Dist.PortB)

	// semente randomica
	rand.Seed(time.Now().UTC().UnixNano())

	// Le os dados das proteinas no DB
	fmt.Println("Loading proteins...")
	id, start, end, err := db.GetProteins(conf.DB)
	if err != nil {
		fmt.Println("Erro no banco de DADOS")
		panic(err)
	}
	fmt.Println("Done")
	// ? Ha vantagem em enviar um sinal de Ok (proteinas lidas) para o master?

	var prob Probabilities

	var tourn Tournament
	tourn = make([]Individual, conf.EDA.Tournament)
	// tourn.rule = make([]*rules.Rule, conf.EDA.Tournament)
	// tourn.fitness = make([]float64, conf.EDA.Tournament)

	r, _ := rules.Create(conf.CA.InitStates, conf.CA.TransStates, conf.CA.HasJoker, conf.CA.R)
	// probabilidade temporaria para ser substituida pelas recebidas
	p_tmp := NewProbs(r.Prm)
	cellAuto := make([]*ca.CellAuto1D, conf.EDA.Tournament)
	for i := 0; i < conf.EDA.Tournament; i++ {
		// tourn.rule[i] = p_tmp.GenRule()
		tourn[i].Rule = p_tmp.GenRule()

		// cellAuto[i], _ = ca.Create1D(id, start, end, tourn.rule[i], conf.CA.Steps, conf.CA.Consensus)
		cellAuto[i], _ = ca.Create1D(id, start, end, tourn[i].Rule, conf.CA.Steps, conf.CA.Consensus)
	}

	// Individuo vencedor do torneio
	var (
		ind    Individual
		b      []byte
		m      string
		conerr error
	)

	for {
		// m é a mensagem com as probabilidades
		m, conerr = receiver.Recv(0)
		// m, err := conn.Request(conf.Dist.TopicFromMaster, []byte("get"), 2*time.Second)
		if conerr == nil {
			// para cada individuo no torneio
			// gera uma regra de acordo com a probabilidade atual
			// roda o automato celular
			// calcula o fitness
			// seleciona o vencedor do torneio
			// retorna sua regra e seu fitness)

			// converte a probabilidade recebida em JSON para uma estrutura
			json.Unmarshal([]byte(m), &prob)
			fmt.Printf("PID: %d, Geracacao: %d\n", prob.PID, prob.Generation)
			// for i := 0; i < len(tourn.rule); i++ {
			for i := 0; i < len(tourn); i++ {

				// copia a probabilidade recebida para a probabilidade dos individuos
				copy(p_tmp.probs, prob.Data)
				// gera a regra e atribui ao membro do torneio
				tourn[i].Rule = p_tmp.GenRule()
				// define a regra do automato como sendo a nova regra
				cellAuto[i].SetRule(tourn[i].Rule)
				// retorna o fitness e outras medidas de desempenho do autômato
				tourn[i].Fitness, tourn[i].Q3 = FitnessAndQ3(cellAuto[i])

				// fmt.Println("Individuo", i, "Fitness", tourn.fitness[i])
				fmt.Println("Individuo", i, "Fitness", tourn[i].Fitness)

			}

			// Ordena os individuos do torneio de acordo com o fitness (maior primeiro)
			sort.Sort(sort.Reverse(tourn))
			// ind.PID, ind.Generation, ind.Rule, ind.Fitness = prob.PID, prob.Generation, tourn.rule[0], tourn.fitness[0]
			ind.PID, ind.Generation, ind.Rule, ind.Fitness, ind.Q3 = prob.PID, prob.Generation, tourn[0].Rule, tourn[0].Fitness, tourn[0].Q3

			// Codifica o individuo vencedor em JSON e envia para o master
			b, _ = json.Marshal(ind)
			fmt.Println("Fitness selecionado", tourn[0].Fitness)
			sender.Send(string(b), 0)

		} else {
			// Erro na conexão
			fmt.Println(err)
		}

	}
}
Beispiel #8
0
func Run(conf Config) error {
	rand.Seed(time.Now().UTC().UnixNano())

	fmt.Println("Loading proteins...")
	id, start, end, err := proteindb.GetProteins(conf.ProteinDB)
	if err != nil {
		panic(err)
	}

	fmt.Println("Initializing probabilities...")
	r, _ := rules.Create(conf.CA.InitStates, conf.CA.TransStates, conf.CA.HasJoker, conf.CA.R)
	probs := NewProbs(r.Prm)
	// fmt.Println(probs)

	var pop Population

	pop.rule = make([]*rules.Rule, conf.EDA.Population)
	pop.fitness = make([]float64, conf.EDA.Population)

	cellAuto := make([]*ca.CellAuto1D, conf.EDA.Population)

	var wg1 sync.WaitGroup
	// tmp := 0
	for i := 0; i < conf.EDA.Population; i++ {
		wg1.Add(1)
		go func(pop *Population, i int) {
			defer wg1.Done()
			pop.rule[i] = probs.GenRule()
			// ca, _ := ca.Create1D(id, start, end, pop.rule[i], conf.CA.Steps, conf.CA.Consensus)
			cellAuto[i], _ = ca.Create1D(id, start, end, pop.rule[i], conf.CA.Steps, conf.CA.Consensus)
			pop.fitness[i] = Fitness(cellAuto[i])
		}(&pop, i) //preciso definir o que por aqui
		if i%48 == 0 && i > 0 {
			fmt.Println("Waiting", i)
			wg1.Wait()
		}
	}
	wg1.Wait()

	fmt.Println("População inicial = ", conf.EDA.Population, "OK")
	// tmp := make([]float64, len(pop.fitness))
	// for j := range tmp {
	// 	tmp[j] = pop.fitness[j] * 1.1
	// }

	var wg2 sync.WaitGroup
	for i := 0; i < conf.EDA.Generations; i++ {
		fmt.Println("Generation", i+1)
		fmt.Println("Adjusting probabilities...")
		probs.AdjustProbs(pop, conf.EDA.Selection, conf.EDA.Tournament)
		fmt.Println("OK")

		if probs.Converged() {
			fmt.Println("Probabilities converged\nDONE")
			break
		}

		if (i+1)%conf.EDA.SaveSteps == 0 {
			ioutil.WriteFile(fmt.Sprintf("%s_%d", conf.EDA.OutputProbs, i+1), []byte(probs.String()), 0644)
		}

		for j := 0; j < len(pop.rule); j++ {
			wg2.Add(1)
			go func(pop *Population, j int) {
				defer wg2.Done()
				pop.rule[j] = probs.GenRule()
				// ca, _ := ca.Create1D(id, start, end, pop.rule[j], conf.CA.Steps, conf.CA.Consensus)
				cellAuto[j].SetRule(pop.rule[j])
				pop.fitness[j] = Fitness(cellAuto[j])

			}(&pop, j)
			if j%24 == 0 && j > 0 {
				fmt.Println("Waiting", j)
				wg2.Wait()
			}
		}
		fmt.Printf("Wait - Setting new rule")
		wg2.Wait()
		fmt.Println("OK")
		//Este é o melhor lugar para criar o grafico? pop
		plot.Histogram(pop.fitness, nil, i)
	}

	err = ioutil.WriteFile(conf.EDA.OutputProbs, []byte(probs.String()), 0644)
	if err != nil {
		fmt.Println("Erro gravar as probabilidades")
		fmt.Println(probs)
	}

	return nil
}
Beispiel #9
0
func RunMaster(conf Config) {

	// cria o emissor que envia as probabilidades para toda a rede na porta A
	sender, _ := zmq.NewSocket(zmq.PUSH)
	defer sender.Close()
	sender.Bind("tcp://*:" + conf.Dist.PortA)

	// cria o receptor que recebe os individuos de toda a rede na porta B
	receiver, _ := zmq.NewSocket(zmq.PULL)
	defer receiver.Close()
	receiver.Bind("tcp://*:" + conf.Dist.PortB)

	// gerar (ou ler -> TODO) as probabilidades iniciais
	r, _ := rules.Create(conf.CA.InitStates, conf.CA.TransStates, conf.CA.HasJoker, conf.CA.R)
	p := NewProbs(r.Prm)

	// a população do DistEDA será de apenas vencedores dos torneios locais,
	// realizados nos slaves. Portanto, população é igual população/n_torneio
	var pop []Individual
	pop = make([]Individual, conf.EDA.Population/conf.EDA.Tournament)

	popFitness := make([]float64, conf.EDA.Population/conf.EDA.Tournament)
	popQ3 := make([]float64, conf.EDA.Population/conf.EDA.Tournament)

	// cria um arquivo de log onde serão salvas as estatisticas por geração, como
	// média e variância do Q3
	fstat, err := os.Create("log")
	if err != nil {
		panic(err)
	}
	defer fstat.Close()

	// os slaves demoram um pouco para inicializar pois precisam acessar o DB e
	// carregar os dados. O master precisa esperar os slaves estarem prontos. Por
	// enquanto, o sinal de inicio é dado manualmente (TODO -> pensar numa forma
	// automática)
	fmt.Print("Press Enter when the workers are ready: ")
	var line string
	fmt.Scanln(&line)
	fmt.Println("Sending tasks to workers...")

	// Inicio do processamento
	fmt.Println("RUNNING MASTER")
	// para cada geracao
	for g := 0; g < conf.EDA.Generations; g++ {
		fmt.Println("GERACAO", g)
		// atualizar as probabilidades de acordo com a populacao dessa geracao
		if g != 0 {
			// TODO refazer a funcao para trabalhar com toda a populacao. Acho que
			// esta feito. Confirmar!!!
			p.AdjustProbs(pop)
		}

		// Criar as probabilidades para serem enviadas no formato JSON.
		// Será enviado o ID (PID) = hash da probabilidade, o número da geração e as
		// probabilidades
		tmp, _ := json.Marshal(p.probs)
		pid := adler32.Checksum(tmp)
		prob := &Probabilities{PID: pid, Generation: g, Data: p.probs}
		b, _ := json.Marshal(prob)

		// Para cada individuo que precisará retornar deve ser emitida uma
		// probabilidade. Uma goroutine fica emitindo probabilidades que vão sendo
		// capturados pelos slaves que após o torneio, devolvem o vencedor
		go func(b *[]byte) {
			for i := 0; i < len(pop); i++ {
				sender.Send(string(*b), 0)
			}
		}(&b)

		// Capta os individuos vencedores gerados pelos slaves
		for i := 0; i < len(pop); {
			m, err := receiver.Recv(0)
			if err == nil {
				json.Unmarshal([]byte(m), &pop[i])
				// Checa pelo ID da probabilidade se o individuo vencedor que chegou foi
				// gerado pela última probabilidade que foi emitida
				if prob.PID == pop[i].PID {
					// fmt.Printf("Individuo id: %d rid: %d g: %d, score: %f\n", g*len(pop)+i, pop[i].PID, pop[i].Generation, pop[i].Fitness)
					popFitness[i] = pop[i].Fitness
					popQ3[i] = pop[i].Q3
					i++
				} else {
					fmt.Println(prob.PID, pop[i].PID)
				}

			} else {
				fmt.Println(err)
			}
		}

		// IMPORTANTE
		// TODO criar um mecanismo para contornar falhas nos nós

		// imprimir e as estatisticas// salva as probabilidades a cada geração
		err := ioutil.WriteFile(conf.EDA.OutputProbs+"_g"+strconv.Itoa(g), []byte(p.String()), 0644)
		if err != nil {
			fmt.Println("Erro gravar as probabilidades")
			fmt.Println(p)
		}

		//  imprimir e as estatisticas
		meanFit, stdFit := stat.MeanStdDev(popFitness, nil)
		meanQ3, stdQ3 := stat.MeanStdDev(popQ3, nil)
		fstat.WriteString(fmt.Sprintf("G: %d, Mean: %.5f, StdDev: %.5f, Mean Q3: %.5f, StdDev Q3: %.5f, \n", g, meanFit, stdFit, meanQ3, stdQ3))
		fmt.Printf("G: %d, Mean: %.5f, StdDev: %.5f, Mean Q3: %.5f, StdDev Q3: %.5f, \n", g, meanFit, stdFit, meanQ3, stdQ3)

	}
	// salvar a melhor regra

}
Beispiel #10
0
func Run(conf Config) error {
	rand.Seed(time.Now().UTC().UnixNano())

	fmt.Println("Loading proteins...")
	id, start, end, err := proteindb.GetProteins(conf.ProteinDB)
	if err != nil {
		panic(err)
	}

	var pop Population

	pop.rule = make([]*rules.Rule, conf.GA.Population)
	pop.fitness = make([]float64, conf.GA.Population)

	var wg1 sync.WaitGroup
	// tmp := 0
	for i := 0; i < conf.GA.Population; i++ {
		wg1.Add(1)
		go func(pop *Population, i int) {
			defer wg1.Done()
			pop.rule[i], _ = rules.Create(conf.CA.InitStates, conf.CA.TransStates, conf.CA.HasJoker, conf.CA.R)
			ca, _ := ca.Create1D(id, start, end, pop.rule[i], conf.CA.Steps, conf.CA.Consensus)
			pop.fitness[i] = Fitness(ca)
		}(&pop, i) //preciso definir o que por aqui
		if i%100 == 0 && i > 0 {
			fmt.Println("Waiting", i)
			wg1.Wait()
		}
	}
	wg1.Wait()

	var selection Selection
	selection.rule = make([]*rules.Rule, conf.GA.Selection)
	selection.fitness = make([]float64, conf.GA.Selection)

	// var tournament Tournament
	// tournament.rule = make([]*rules.Rule, conf.GA.Tournament)
	// tournament.fitness = make([]float64, conf.GA.Tournament)
	var wg2 sync.WaitGroup
	for i := 0; i < conf.GA.Generations; i++ {
		fmt.Println("Gen", i)
		sort.Sort(sort.Reverse(pop))
		for j := 0; j < conf.GA.Selection; j++ {
			winner := len(pop.rule)
			for k := 0; k < conf.GA.Tournament; k++ {
				x := rand.Intn(len(pop.rule))
				if x < winner {
					winner = x
				}
			}

			//sort.Sort(sort.Reverse(tournament))

			selection.rule[j] = pop.rule[winner]
			selection.fitness[j] = pop.fitness[winner]
		}
		fmt.Println("Selection OK")
		plot.Histogram(pop.fitness, selection.fitness, i)
		fmt.Println("Plot", i, "ok")
		for p := 0; p < len(pop.rule); p++ {
			wg2.Add(1)
			go func(pop *Population, p int) {
				defer wg2.Done()
				s := rand.Intn(len(selection.rule))
				Mutate(selection.rule[s], conf.GA.Mutation)
				pop.rule[p] = selection.rule[s]
				ca, _ := ca.Create1D(id, start, end, pop.rule[p], conf.CA.Steps, conf.CA.Consensus)
				pop.fitness[p] = Fitness(ca)
			}(&pop, p)
			if p%10 == 0 && p > 0 {
				fmt.Println("Waiting", p)
				wg2.Wait()
			}
		}
		fmt.Println("New pop OK")
	}

	return nil
}