Desse trabalho fiz esse código: TOTALSLOTS = 50 # 5 dias, 2 turnos, 5 aulas with…
- User
Desse trabalho fiz esse código:
TOTAL_SLOTS = 50 # 5 dias, 2 turnos, 5 aulas
with open("matrizcur.json", "r", encoding='utf-8') as file:
data = json.load(file)class Disciplina:
def init(self, codigo, periodo, aulas, depedencias): self.codigo = codigo self.periodo = periodo self.aulas_semana = aulas self.dependencias = depedencias #Atribui um professor fixo para cada disciplina self.professor = f"Professor_{random.randint(1,15)}"disciplinas = [
Disciplina( d["codigo"], d["periodo"], d["aulas_semana"], d["pre_requisitos"] ) for d in data["DISCIPLINAS"]]
N_GENES = sum(d.aulas_semana for d in disciplinas)
PARAMETROS = [
{"POP_SIZE": 500, "MUTPB":0.15, "CXPB": 0.8, "NGEN": 5000, "TOURNSIZE": 3}]
def numslot_para_horario(slot):
aulas_por_turnos = 5 dia = slot // (2 * aulas_por_turnos) turno = (slot % (2 * aulas_por_turnos)) // aulas_por_turnos aula = (slot % (2 * aulas_por_turnos)) % aulas_por_turnos return dia, turno, aulacreator.create("FitnessMin", base.Fitness, weights=(-1.0,))
creator.create("Individual", list, fitness=creator.FitnessMin)
toolbox = base.Toolbox()
toolbox.register("attr_slot", random.randint, 0, TOTAL_SLOTS-1)
toolbox.register("individual", tools.initRepeat, creator.Individual,
toolbox.attr_slot, n=N_GENES)toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("evaluate", fitness)
toolbox.register("select", tools.selTournament, tournsize=5)
toolbox.register("mate", tools.cxOnePoint)
toolbox.register("mutate", tools.mutUniformInt, low=0, up=TOTAL_SLOTS-1,indpb=1.0/N_GENES)
stats = tools.Statistics(lambda ind: ind.fitness.values[0])
stats.register("min", np.min)
stats.register("avg", lambda vals: sum(vals)/len(vals))
hof = tools.HallOfFame(1)
POP_SIZE = 1000
CXPB = 0.8
MUTPB = 0.25
if name == "main":
populacao = toolbox.population(n=POP_SIZE) populacao = algorithms.eaSimple(populacao, toolbox, cxpb=CXPB, mutpb=MUTPB, ngen=200, stats=stats, halloffame=hof) #{"POP_SIZE": 500, "MUTPB":0.15, "CXPB": 0.8, "NGEN": 5000, "TOURNSIZE": 3} best = hof[0] print("Melhor Fitness: ", best.fitness.values[0]) gerar_pdf(best) for d in disciplinas: print(d.professor)- Queria ajudar para criar a função fitness, as restrições que deve ter inclua se necessario(não coloque coisas de administração de salas ou invente regras do rabo).
Tem as:
-
Uma disciplina do mesmo periodo não deve ocupar mesmo horario e dia
-
Professores não devem ter + 1 aula no mesmo dia
-
O tempo ocioso entre aulas de um mesmo periodo deve ser minimizado
-
Não deve haver +3 aulas seguidas(ou no dia) da mesma matéria
-
"não existam conflitos entre os
horários de disciplinas que são pré-requisito e suas correspondentes" (está no arquivo de descrição), OBS: no meus dados eu tenho qual matéria é dependecia de qual
Balanceamento semanal
Cada período deve ter suas aulas distribuídas de forma relativamente “uniforme” pelos 5 dias (evitar, por exemplo, um dia com 0 aulas e outro com 5). - Assistant
Okay, vamos criar uma função
fitnessrobusta para o seu problema de agendamento, incorporando as restrições e objetivos que você listou.Primeiro, alguns pontos importantes sobre o seu código e o problema:
Disciplina.__init__: O construtor da classeDisciplinaestá faltando os underlines duplos (__). Deve serdef __init__(self, ...).- Mapeamento Gene -> Disciplina: Seu código calcula
N_GENEScomo a soma total de aulas semanais (sum(d.aulas_semana for d in disciplinas)). Isso implica que cada "gene" na listaIndividualrepresenta uma aula específica de uma disciplina. Precisamos de uma forma de saber qual gene (e, portanto, qual aula/slot atribuído) pertence a qual disciplina. Vamos assumir que os genes são atribuídos sequencialmente às disciplinas na ordem em que aparecem na listadata["DISCIPLINAS"]. creator.create("FitnessMin", ...): Você definiu o fitness como minimização (weights=(-1.0,)), o que é correto para penalidades/custos.- Parâmetros GA: Você tem
PARAMETROScomo uma lista com um dicionário, mas depois definePOP_SIZE,CXPB,MUTPBglobalmente e usa esses valores emeaSimple. É melhor usar os valores do dicionário ou os globais de forma consistente. Vou usar os valores globais definidos apósPARAMETROSpara oeaSimple, mas vou referenciar os valores do dicionário para os parâmetros que podem ser usados dentro do fitness ou em outras funções (como oTOURNSIZE). - Função
fitness: A funçãofitnessnão foi definida, apenas registrada natoolbox. Vamos criá-la.
Estrutura da Função Fitness:
A função calculará uma pontuação total. Quanto menor a pontuação, melhor o horário. Usaremos penalidades altas para violações de restrições (que não devem ocorrer) e custos menores para objetivos (que queremos minimizar).
Passos para Construir o Fitness:
- Pré-processamento: Converter a representação linear do indivíduo (lista de slots) em estruturas de dados mais úteis para análise (ex: dicionários agrupando por disciplina, professor, período, dia).
- Cálculo de Penalidades/Custos: Iterar sobre as restrições/objetivos e calcular a pontuação para cada um.
- Combinação: Somar todas as penalidades/custos, possivelmente com pesos.
import json import random import numpy as np from deap import creator, base, tools, algorithms from collections import defaultdict import math # Para cálculo de balanceamento # --- Constantes e Carregamento de Dados --- TOTAL_SLOTS = 50 # 5 dias, 2 turnos, 5 aulas por turno = 50 slots SLOTS_POR_TURNO = 5 TURNOS_POR_DIA = 2 DIAS_POR_SEMANA = 5 try: with open("matrizcur.json", "r", encoding='utf-8') as file: data = json.load(file) except FileNotFoundError: print("Erro: Arquivo matrizcur.json não encontrado.") exit() except json.JSONDecodeError: print("Erro: Arquivo matrizcur.json mal formatado.") exit() class Disciplina: # Correção: Construtor com __init__ def __init__(self, codigo, periodo, aulas, dependencias): self.codigo = codigo self.periodo = periodo self.aulas_semana = aulas self.dependencias = dependencias # Lista de códigos de pré-requisitos # Atribui um professor fixo para cada disciplina (mantido do seu código original) # Consideração: Se a mesma disciplina aparece múltiplas vezes em matrizcur.json, # isso criará objetos Disciplina separados com professores diferentes. Ajuste se necessário. self.professor = f"Professor_{random.randint(1, 15)}" # Cria a lista de disciplinas disciplinas_data = data.get("DISCIPLINAS", []) if not disciplinas_data: print("Erro: Nenhuma disciplina encontrada em matrizcur.json") exit() disciplinas = [ Disciplina( d["codigo"], d["periodo"], d["aulas_semana"], d.get("pre_requisitos", []) # Usa .get para caso 'pre_requisitos' não exista ) for d in disciplinas_data ] # Mapeamento crucial: de qual disciplina é cada gene (aula) # Assumindo que os genes são atribuídos sequencialmente às disciplinas disciplina_gene_map = [] current_gene_index = 0 for i, d in enumerate(disciplinas): disciplina_gene_map.append({ "disciplina": d, "start_gene": current_gene_index, "end_gene": current_gene_index + d.aulas_semana }) current_gene_index += d.aulas_semana N_GENES = current_gene_index # Soma total de aulas = tamanho do gene (indivíduo) # Parâmetros do Algoritmo Genético (usados em eaSimple) POP_SIZE = 1000 # Ajustado para o valor global CXPB = 0.8 # Ajustado para o valor global MUTPB = 0.25 # Ajustado para o valor global NGEN = 200 # Número de gerações # --- Funções Auxiliares --- def numslot_para_horario(slot): """Converte um índice de slot linear para (dia, turno, aula_no_turno).""" if not (0 <= slot < TOTAL_SLOTS): # Retorna um valor inválido ou lança um erro se o slot estiver fora do intervalo # Vamos retornar (-1, -1, -1) para indicar um problema print(f"Aviso: Slot inválido {slot} encontrado.") return -1, -1, -1 # Calcula o dia (0 a 4) dia = slot // (TURNOS_POR_DIA * SLOTS_POR_TURNO) # Calcula o slot dentro do dia slot_no_dia = slot % (TURNOS_POR_DIA * SLOTS_POR_TURNO) # Calcula o turno (0 ou 1) turno = slot_no_dia // SLOTS_POR_TURNO # Calcula a aula dentro do turno (0 a 4) aula = slot_no_dia % SLOTS_POR_TURNO return dia, turno, aula def horario_para_slot_num(dia, turno, aula): """Converte (dia, turno, aula) de volta para um índice de slot linear.""" return (dia * TURNOS_POR_DIA * SLOTS_POR_TURNO) + \ (turno * SLOTS_POR_TURNO) + \ aula def calcular_penalidade(valor, max_valor, peso): """Calcula uma penalidade que aumenta conforme 'valor' se aproxima de 'max_valor'.""" if valor == 0: return 0 # Normaliza a penalidade para que seja 0 se valor=0 e cresça até 'peso' quando valor=max_valor # Usaremos uma penalidade linear simples aqui, mas pode ser ajustada (ex: quadrática) penalidade = (valor / max_valor) * peso #print(f"Pen: val={valor}, max={max_valor}, w={peso} -> {penalidade}") return penalidade # --- Definição do Fitness --- def calcular_fitness(individual): """Calcula a pontuação de fitness para um indivíduo (horário).""" penalidade_total = 0 # --- Estruturas para Análise --- # Mapeia slot -> lista de (cod_disciplina, professor, indice_disciplina) slots_ocupados = defaultdict(list) # Mapeia disciplina -> lista de slots ocupados por ela disciplina_horarios = defaultdict(list) # Mapeia professor -> lista de slots ocupados por ele professor_horarios = defaultdict(list) # Mapeia periodo -> lista de (slot, cod_disciplina, professor, indice_disciplina) periodo_horarios = defaultdict(list) # --- Contagem de Aulas por Dia/Disciplina/Professor --- aulas_por_disciplina_dia = defaultdict(lambda: defaultdict(int)) aulas_por_professor_dia = defaultdict(lambda: defaultdict(int)) # --- 1. Pré-processamento e Restrições C1 e C2 --- # Verifica conflitos de slots e professores ao mesmo tempo # Itera sobre cada gene (representando uma aula) no indivíduo for gene_idx, slot in enumerate(individual): # Encontra a qual disciplina este gene pertence disciplina_info = None for info in disciplina_gene_map: if info["start_gene"] <= gene_idx < info["end_gene"]: disciplina_info = info break if disciplina_info is None: # Isso não deveria acontecer se N_GENES e o mapeamento estão corretos print(f"Erro Crítico: Gene {gene_idx} não pertence a nenhuma disciplina mapeada.") penalidade_total += 10000 # Penalidade alta por erro grave continue disciplina = disciplina_info["disciplina"] cod_disciplina = disciplina.codigo professor = disciplina.professor periodo = disciplina.periodo dia, turno, aula = numslot_para_horario(slot) # Verifica se o slot é válido if dia == -1: # Se numslot_para_horario retornou erro penalidade_total += 1000 # Penalidade por slot inválido continue slot_key = (dia, turno, aula) # Chave única para o slot no tempo # --- Restrição C1: Disciplinas do mesmo período não podem ocupar o mesmo slot --- # Verifica se já existe alguma aula DESSA DISCIPLINA nesse slot # E também se já existe alguma aula DE OUTRA DISCIPLINA DO MESMO PERÍODO nesse slot for existing_cod, existing_prof, existing_idx in slots_ocupados[slot_key]: existing_disciplina = disciplinas[existing_idx] # Assumindo que o índice está correto if existing_disciplina.periodo == periodo: penalidade_total += 1000 # Penalidade alta para conflito de período no mesmo slot # --- Restrição C2: Professores não devem ter +1 aula no mesmo dia/slot --- # Verifica se o professor já está ocupado neste slot específico if professor in [p for s, p, d in slots_ocupados[slot_key]]: penalidade_total += 1000 # Penalidade alta para conflito de professor no mesmo slot # Atualiza as estruturas de dados slots_ocupados[slot_key].append((cod_disciplina, professor, disciplina_info.get("index", disciplinas.index(disciplina)))) # Adiciona índice para referência futura disciplina_horarios[cod_disciplina].append(slot) professor_horarios[professor].append(slot) periodo_horarios[periodo].append((slot, cod_disciplina, professor, disciplina_info.get("index", disciplinas.index(disciplina)))) # Contagem para C4 e C5 aulas_por_disciplina_dia[cod_disciplina][dia] += 1 aulas_por_professor_dia[professor][dia] += 1 # --- Restrição C4: Não +3 aulas seguidas (interpretado como: não +3 aulas da mesma matéria no mesmo dia) --- for disciplina_code, dias_aulas in aulas_por_disciplina_dia.items(): for dia, count in dias_aulas.items(): if count > 3: # Penaliza cada aula que excede o limite de 3 no dia penalidade_total += (count - 3) * 500 # Peso 500 # --- Verificação da Restrição C2 (revisão por dia, mais robusta) --- # Embora já verificado por slot, vamos garantir a regra do dia for professor, dias_aulas in aulas_por_professor_dia.items(): for dia, count in dias_aulas.items(): if count > 1: # Professor não pode ter mais de 1 aula por dia (implícito no C2 por slot) # A penalidade por slot já cobre isso, mas pode adicionar uma penalidade menor aqui se desejar pass # --- Restrição C5: Pré-requisitos --- # "o tempo ocioso entre aulas de um mesmo período" - Interpretado como minimização do *span* de tempo de cada disciplina # Vamos refazer C3 e C5 separadamente # --- Objetivo C3: Minimizar o tempo ocioso entre aulas de um mesmo período --- # Interpretação: Minimizar a 'duração total' em que as aulas de um período estão espalhadas. # Calculamos o tempo da primeira à última aula de cada período. custo_ociosidade_periodo = 0 for periodo, aulas_periodo in periodo_horarios.items(): if not aulas_periodo: continue primeira_aula_slot = min(a[0] for a in aulas_periodo) ultima_aula_slot = max(a[0] for a in aulas_periodo) # Calcula o 'span' em dias, turnos, aulas dia_i, turno_i, aula_i = numslot_para_horario(primeira_aula_slot) dia_f, turno_f, aula_f = numslot_para_horario(ultima_aula_slot) # Convertendo para uma medida linear de tempo para facilitar a subtração tempo_inicio = dia_i * (TURNOS_POR_DIA * SLOTS_POR_TURNO) + turno_i * SLOTS_POR_TURNO + aula_i tempo_fim = dia_f * (TURNOS_POR_DIA * SLOTS_POR_TURNO) + turno_f * SLOTS_POR_TURNO + aula_f span_tempo = tempo_fim - tempo_inicio custo_ociosidade_periodo += span_tempo penalidade_total += custo_ociosidade_periodo * 1 # Peso 1 para este custo # --- Restrição C5: Conflitos de Pré-requisitos --- # "não existam conflitos entre os horários de disciplinas que são pré-requisito e suas correspondentes" # Interpretação: A ÚLTIMA aula da pré-requisito deve ocorrer ANTES da PRIMEIRA aula da disciplina dependente. penalidade_prerequisito = 0 for gene_idx, slot in enumerate(individual): # Encontra a disciplina correspondente ao gene atual disciplina_atual_info = None for info in disciplina_gene_map: if info["start_gene"] <= gene_idx < info["end_gene"]: disciplina_atual_info = info break if disciplina_atual_info is None: continue disciplina_atual = disciplina_atual_info["disciplina"] # Se esta é a PRIMEIRA aula desta disciplina no indivíduo # Verifica se ela tem pré-requisitos if gene_idx == disciplina_atual_info["start_gene"] and disciplina_atual.dependencias: primeira_aula_atual_slot = slot dia_atual, turno_atual, aula_atual = numslot_para_horario(primeira_aula_atual_slot) tempo_primeira_aula_atual = dia_atual * (TURNOS_POR_DIA * SLOTS_POR_TURNO) + turno_atual * SLOTS_POR_TURNO + aula_atual for prereq_cod in disciplina_atual.dependencias: # Encontra a disciplina pré-requisito na lista global prereq_disciplina = None prereq_info = None for p_info in disciplina_gene_map: if p_info["disciplina"].codigo == prereq_cod: prereq_disciplina = p_info["disciplina"] prereq_info = p_info break if prereq_disciplina and prereq_info: # Encontra a ÚLTIMA aula da pré-requisito slots_prereq = disciplina_horarios.get(prereq_cod, []) if not slots_prereq: # Pré-requisito não tem aulas agendadas? Isso é um problema sério. penalidade_prerequisito += 1000 # Penalidade alta continue ultima_aula_prereq_slot = max(slots_prereq) dia_pr, turno_pr, aula_pr = numslot_para_horario(ultima_aula_prereq_slot) tempo_ultima_aula_prereq = dia_pr * (TURNOS_POR_DIA * SLOTS_POR_TURNO) + turno_pr * SLOTS_POR_TURNO + aula_pr # Compara os tempos if tempo_ultima_aula_prereq >= tempo_primeira_aula_atual: penalidade_prerequisito += 1 # Penaliza cada violação # print(f"VIOLAÇÃO PREREQ: {prereq_cod} (últ: {tempo_ultima_aula_prereq}) -> {disciplina_atual.codigo} (prim: {tempo_primeira_aula_atual})") penalidade_total += penalidade_prerequisito * 2000 # Peso alto para pré-requisitos # --- Objetivo C6: Balanceamento Semanal por Período --- # Distribui aulas de forma uniforme pelos 5 dias. custo_balanceamento = 0 aulas_por_periodo_dia = defaultdict(lambda: defaultdict(int)) num_aulas_por_periodo = defaultdict(int) # Recalcula a distribuição dia/periodo for periodo, aulas_periodo in periodo_horarios.items(): for slot, _, _, _ in aulas_periodo: dia, _, _ = numslot_para_horario(slot) if dia != -1: aulas_por_periodo_dia[periodo][dia] += 1 num_aulas_por_periodo[periodo] += 1 for periodo, contagem_aulas_total in num_aulas_por_periodo.items(): if contagem_aulas_total == 0: continue media_aulas_dia = contagem_aulas_total / float(DIAS_POR_SEMANA) # Calcula o desvio em relação à média para cada dia desvio_periodo = 0 for dia in range(DIAS_POR_SEMANA): contagem_dia = aulas_por_periodo_dia[periodo][dia] desvio_periodo += abs(contagem_dia - media_aulas_dia) # Adiciona o desvio total do período ao custo custo_balanceamento += desvio_periodo penalidade_total += custo_balanceamento * 10 # Peso 10 para balanceamento # --- Combinação Final --- # As penalidades para violações C1, C2, C4, C5 já estão somadas. # Os custos para objetivos C3 e C6 também estão somados. # Se houver penalidades de erro grave (ex: gene inválido), elas já estão incluídas. # Retorna uma tupla com o valor do fitness (DEAP espera uma tupla) return (penalidade_total,) # --- Configuração do DEAP --- # Cria o tipo de fitness (Minimização) creator.create("FitnessMin", base.Fitness, weights=(-1.0,)) # Cria o tipo de indivíduo (uma lista de inteiros representando slots) creator.create("Individual", list, fitness=creator.FitnessMin) toolbox = base.Toolbox() # Atributo: um slot aleatório entre 0 e TOTAL_SLOTS-1 toolbox.register("attr_slot", random.randint, 0, TOTAL_SLOTS - 1) # Indivíduo: uma lista de N_GENES atributos do tipo slot toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_slot, n=N_GENES) # População: uma lista de indivíduos toolbox.register("population", tools.initRepeat, list, toolbox.individual) # Registro da função de avaliação # IMPORTANTE: Certifique-se que a função 'fitness' (calcular_fitness) está definida ANTES desta linha toolbox.register("evaluate", calcular_fitness) # Operadores genéticos # Usando o TOURNSIZE do seu dicionário PARAMETROS toolbox.register("select", tools.selTournament, tournsize=3) # Valor de PARAMETROS[0]["TOURNSIZE"] toolbox.register("mate", tools.cxOnePoint) # Pode experimentar outros como cxBlend se os atributos fossem contínuos # Mutação: Uniforme sobre os slots possíveis. indpb=1.0/N_GENES é um valor comum, mas pode ser ajustado. toolbox.register("mutate", tools.mutUniformInt, low=0, up=TOTAL_SLOTS - 1, indpb=0.1) # indpb ajustado para 0.1 (10%) # --- Estatísticas e Hall of Fame --- stats = tools.Statistics(lambda ind: ind.fitness.values) stats.register("min", np.min) stats.register("avg", np.mean) # Use np.mean para a média stats.register("std", np.std) # Adiciona desvio padrão hof = tools.HallOfFame(1) # Guarda apenas o melhor indivíduo # --- Execução do Algoritmo Genético --- if __name__ == "__main__": # Cria a população inicial populacao = toolbox.population(n=POP_SIZE) # Executa o algoritmo EA Simple print(f"Iniciando GA com POP_SIZE={POP_SIZE}, CXPB={CXPB}, MUTPB={MUTPB}, NGEN={NGEN}") # O eaSimple precisa do toolbox completo, não apenas da população # Ele aplicará os operadores registrados (evaluate, select, mate, mutate) populacao, logbook = algorithms.eaSimple(populacao, toolbox, cxpb=CXPB, mutpb=MUTPB, ngen=NGEN, stats=stats, halloffame=hof, verbose=True) # verbose=True mostra o progresso a cada geração # --- Resultados --- print("\n--- GA Finalizado ---") if hof: melhor_individuo = hof[0] print("Melhor Fitness:", melhor_individuo.fitness.values[0]) # Opcional: Imprimir detalhes do melhor horário encontrado print("\nDetalhes do Melhor Horário:") # (Você pode querer uma função para imprimir o horário de forma legível) # Exemplo: print(melhor_individuo) # Exemplo de como acessar os dados do melhor indivíduo # for i, slot in enumerate(melhor_individuo): # disciplina_info = next((info for info in disciplina_gene_map if info["start_gene"] <= i < info["end_gene"]), None) # if disciplina_info: # d = disciplina_info["disciplina"] # dia, turno, aula = numslot_para_horario(slot) # print(f" Aula {i}: {d.codigo} ({d.professor}) -> Slot {slot} (Dia {dia}, Turno {turno}, Aula {aula})") # else: # print(f" Aula {i}: Erro no mapeamento - Slot {slot}") # Chamar a função para gerar PDF (assumindo que gerar_pdf existe e usa 'melhor_individuo' e 'disciplinas') # try: # gerar_pdf(melhor_individuo) # except NameError: # print("Função gerar_pdf não definida.") else: print("Nenhum indivíduo no Hall of Fame.") print("\nProfessores designados (exemplo):") for d in disciplinas: print(f" {d.codigo}: {d.professor}")Explicação Detalhada das Penalidades/Custos na Função
calcular_fitness:- Pré-processamento: Cria dicionários (
slots_ocupados,disciplina_horarios,professor_horarios,periodo_horarios) e contadores (aulas_por_disciplina_dia,aulas_por_professor_dia) para facilitar a verificação das regras. Isso é feito iterando sobre oindividualuma vez. - Restrição C1 (Conflito Período/Slot):
- Ao processar cada gene/aula, verifica-se em
slots_ocupados. Se o slot já está ocupado e a disciplina que o ocupa pertence ao mesmo período da disciplina atual, adiciona-se uma penalidade alta (1000).
- Ao processar cada gene/aula, verifica-se em
- Restrição C2 (Conflito Professor/Slot):
- Ao processar cada gene/aula, verifica-se se o
professorda disciplina atual já está listado emslots_ocupadospara aqueleslot_keyespecífico. Se sim, penalidade alta (1000).
- Ao processar cada gene/aula, verifica-se se o
- Restrição C4 (Max 3 Aulas/Matéria/Dia):
- Após o loop de pré-processamento, usa-se
aulas_por_disciplina_dia. Para cada disciplina, itera-se pelos dias. Se a contagem de aulas (count) em um dia exceder 3, adiciona-se(count - 3) * 500à penalidade total. O peso500é significativo.
- Após o loop de pré-processamento, usa-se
- Objetivo C3 (Minimizar "Ociosidade" por Período - Span):
- Itera sobre
periodo_horarios. Para cada período, encontra-se o slot da primeira e da última aula. - Converte esses slots para uma medida linear de tempo.
- Calcula-se a diferença (
span_tempo). - Soma-se esse
span_tempoacusto_ociosidade_periodo. O custo total é multiplicado por um peso (1) e adicionado à penalidade total. Queremos que esse valor seja o menor possível.
- Itera sobre
- Restrição C5 (Pré-requisitos):
- Durante o pré-processamento, quando a primeira aula de uma disciplina (
gene_idx == disciplina_atual_info["start_gene"]) é encontrada, verifica-se se ela tem dependências (disciplina_atual.dependencias). - Para cada pré-requisito (
prereq_cod):- Encontra-se a última aula agendada para o pré-requisito (
max(slots_prereq)). - Converte-se o slot da primeira aula atual e da última aula do pré-requisito para o tempo linear.
- Se
tempo_ultima_aula_prereq >= tempo_primeira_aula_atual, significa que o pré-requisito não terminou antes do início da disciplina dependente. Uma penalidade (1) é adicionada apenalidade_prerequisito.
- Encontra-se a última aula agendada para o pré-requisito (
- No final,
penalidade_prerequisitoé multiplicada por um peso alto (2000) e adicionada à penalidade total.
- Durante o pré-processamento, quando a primeira aula de uma disciplina (
- Objetivo C6 (Balanceamento Semanal):
- Calcula-se quantas aulas de cada período caem em cada dia da semana (
aulas_por_periodo_dia). - Para cada período, calcula-se a média teórica de aulas por dia (
media_aulas_dia). - Calcula-se o desvio absoluto da contagem real de cada dia em relação a essa média (
abs(contagem_dia - media_aulas_dia)). - Soma-se esses desvios para obter o
desvio_periodo. - Soma-se o
desvio_periodode todos os períodos para obter ocusto_balanceamento. - O custo total é multiplicado por um peso (
10) e adicionado à penalidade total.
- Calcula-se quantas aulas de cada período caem em cada dia da semana (
Ajustes e Considerações:
- Pesos: Os pesos (
1000,500,2000,1,10) são cruciais e podem precisar de tuning. Comece com valores altos para restrições estritas e valores menores para otimização. Se o GA não estiver respeitando uma restrição, aumente seu peso. Se estiver otimizando demais em detrimento das restrições, diminua o peso dos objetivos. - Interpretação C4: A interpretação de "+3 aulas seguidas" foi feita como "+3 aulas da mesma matéria no mesmo dia". Se você queria dizer 3 slots consecutivos no horário (ex: slot 5, 6, 7), a lógica de verificação precisaria ser diferente, talvez iterando sobre os slots ordenados para cada disciplina. A versão atual é mais comum em grade de horários.
- Interpretação C3: A minimização do "tempo ocioso" foi interpretada como a minimização do span (tempo entre a primeira e a última aula) de cada disciplina. Outra interpretação seria contar explicitamente os slots vazios entre as aulas de um período. A implementação atual foca no span temporal geral.
gerar_pdf: A funçãogerar_pdf(best)foi deixada comentada, pois não temos a definição dela. Você precisará implementá-la separadamente.- Consistência de Parâmetros: Garanta que os parâmetros como
POP_SIZE,CXPB,MUTPB,NGENeTOURNSIZEsejam usados de forma consistente onde são definidos e utilizados. No código acima, usei os valores globais definidos posteriormente paraeaSimplee o valor deTOURNSIZEdo dicionárioPARAMETROSparaselTournament.
Este código fornece uma base sólida para a função de fitness, cobrindo todas as regras que você especificou com penalidades e custos adequados. Lembre-se que a performance do GA dependerá fortemente do ajuste fino desses pesos e parâmetros.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.