genetic

bad_apple.exs (3525B)

---

 defmodule BadApple.FrameCtx do
   use Agent
 
   def start_link(_opts \\ []) do
     Agent.start_link(fn -> [] end, name: __MODULE__)
   end
 
   def set_target(bits), do: Agent.update(__MODULE__, fn _ -> bits end)
   def get_target(), do: Agent.get(__MODULE__, & &1)
 end
 
 defmodule BadApple do
   alias Types.Chromosome
   @behaviour Problem
 
   @width 48
   @height 36
   @size @width * @height
 
   @impl true
   def genotype do
     genes =
       Stream.repeatedly(fn -> Enum.random([0, 1]) end)
       |> Enum.take(@size)
 
     %Chromosome{genes: genes, size: @size}
   end
 
   @impl true
   def fitness_function(%Chromosome{genes: genes}) do
     target = BadApple.FrameCtx.get_target()
 
     matches =
       Enum.zip(genes, target)
       |> Enum.count(fn {a, b} -> a == b end)
 
     matches / @size
   end
 
   @impl true
   def terminate?(population, generation) do
     best = hd(population)
     best.fitness >= 0.985 or generation >= 120
   end
 end
 
 defmodule BadApple.FrameIO do
   def load_bits(path) do
     {:ok, image} = Vix.Vips.Image.new_from_file(path)
     width = Vix.Vips.Image.width(image)
     height = Vix.Vips.Image.height(image)
     {:ok, bin} = Vix.Vips.Image.write_to_binary(image)
 
     expected = width * height
 
     if byte_size(bin) != expected do
       raise "Expected #{expected} bytes, got #{byte_size(bin)} for #{path}"
     end
 
     for <<px <- bin>> do
       if px >= 128, do: 1, else: 0
     end
   end
 end
 
 defmodule BadApple.Output do
   @width 48
   @height 36
 
   def save_bits_as_png(bits, out_path) do
     bytes =
       bits
       |> Enum.map(fn b -> if b == 1, do: 255, else: 0 end)
       |> :erlang.list_to_binary()
 
     {:ok, image} =
       Vix.Vips.Image.new_from_binary(bytes, @width, @height, 1, :VIPS_FORMAT_UCHAR)
 
     :ok = File.mkdir_p!(Path.dirname(out_path))
     :ok = Vix.Vips.Image.write_to_file(image, out_path)
   end
 end
 
 {:ok, _} = BadApple.FrameCtx.start_link()
 start_frame = 501
 count = 200
 
 frame_paths =
   "priv/frames_target/*.png"
   |> Path.wildcard()
   |> Enum.sort()
   |> Enum.drop(start_frame - 1)
   |> Enum.take(count)
 
 IO.puts("Processing #{length(frame_paths)} frames...")
 
 last_best = nil
 
 for {frame_path, idx} <- Enum.with_index(frame_paths, 1), reduce: last_best do
   prev_best ->
     target_bits = BadApple.FrameIO.load_bits(frame_path)
     BadApple.FrameCtx.set_target(target_bits)
 
     init_type =
       if prev_best do
         fn genotype, opts ->
           population_size = Keyword.get(opts, :population_size, 60)
           seed = prev_best.genes
 
           seeded =
             Enum.map(1..population_size, fn _ ->
               genes =
                 Enum.map(seed, fn bit ->
                   if :rand.uniform() < 0.10, do: 1 - bit, else: bit
                 end)
 
               %Types.Chromosome{genes: genes, size: length(genes)}
             end)
 
           [genotype.() | tl(seeded)]
         end
       else
         &Toolbox.Initialize.random/2
       end
 
     {best, generation} =
       Genetic.run(BadApple,
         population_size: 100,
         initialization_type: init_type,
         selection_type: &Toolbox.Selection.elite/2,
         mutation_type: &Toolbox.Mutation.flip/2,
         mutation_rate: 0.010,
         crossover_type: &Toolbox.Crossover.uniform/3
       )
 
     out_path = "priv/frames_out/#{String.pad_leading(Integer.to_string(idx), 5, "0")}.png"
     BadApple.Output.save_bits_as_png(best.genes, out_path)
 
     IO.puts(
       "\nFrame #{idx} done | gen=#{generation} | fitness=#{Float.round(best.fitness, 4)} | #{Path.basename(frame_path)}"
     )
 
     best
 end