Tahukah kamu Algoritma Genetika dan Penerapannya dalam Industri

Apa itu Algoritma Genetika?

Algoritma Genetika (Genetic Algorithm, GA) adalah metode pencarian dan optimasi yang terinspirasi oleh proses seleksi alam dalam evolusi biologis. Algoritma ini menggunakan mekanisme seperti seleksi, crossover, dan mutasi untuk menemukan solusi optimal dalam ruang solusi yang besar dan kompleks.

Komponen Utama Algoritma Genetika

1. Populasi: Kumpulan kandidat solusi yang disebut kromosom.
2. Kromosom: Representasi dari solusi potensial, biasanya dalam bentuk string biner atau array.
3. Fitness Function: Fungsi yang mengevaluasi seberapa baik sebuah kromosom sebagai solusi.
4. Seleksi: Proses memilih kromosom yang akan digunakan untuk reproduksi berdasarkan fitness-nya.
5. Crossover (Rekombinasi): Proses menggabungkan dua kromosom untuk menghasilkan keturunan baru.
6. Mutasi: Proses mengubah satu atau lebih gen dalam kromosom untuk menjaga keanekaragaman populasi.

Rumus dan Fungsi

1. Fitness Function (F): [ F(x) = \text{Fitness Function yang tergantung pada masalah spesifik} ]

2. Seleksi (Selection):

   • Roulette Wheel Selection: Probabilitas pemilihan: [ P(i) = \frac{F(i)}{\sum_{j=1}^{N} F(j)} ]

3. Crossover:

   • Single-point Crossover: Memilih satu titik di kromosom untuk membagi dan menggabungkan dua induk. [ \text{Child1} = \text{Parent1}[0:k] + \text{Parent2}[k:N] ] [ \text{Child2} = \text{Parent2}[0:k] + \text{Parent1}[k:N] ]

4. Mutasi:

   • Bit-flip Mutation: Mengubah nilai bit secara acak. [ \text{Mutated Gene} = \text{Original Gene} \oplus 1 ]

Penggunaan di Industri

Algoritma Genetika digunakan di berbagai industri untuk memecahkan masalah yang kompleks dan memerlukan optimasi. Berikut beberapa contohnya:

1. Industri Manufaktur:

   • Penjadwalan Produksi: Mengoptimalkan urutan produksi untuk meminimalkan waktu dan biaya.
   • Desain Produk: Menemukan konfigurasi optimal dari komponen produk.

2. Industri Transportasi:

   • Rute Pengiriman: Mengoptimalkan rute untuk kendaraan pengiriman agar mengurangi biaya dan waktu tempuh.
   • Penjadwalan Penerbangan: Mengatur jadwal penerbangan untuk mengoptimalkan penggunaan pesawat dan kru.

3. Industri Keuangan:

   • Optimasi Portofolio: Menentukan kombinasi investasi terbaik untuk memaksimalkan keuntungan dan mengurangi risiko.
   • Prediksi Pasar: Memprediksi pergerakan pasar dan menentukan strategi perdagangan.

4. Industri Teknologi Informasi:

   • Optimasi Jaringan: Mengoptimalkan konfigurasi jaringan untuk meningkatkan kinerja dan mengurangi biaya.
   • Penjadwalan Tugas di Komputasi Awan: Mengalokasikan tugas ke sumber daya komputasi secara efisien.

5. Industri Energi:

   • Pengelolaan Energi: Mengoptimalkan distribusi dan penggunaan energi untuk mengurangi pemborosan.
   • Desain Sistem Energi Terbarukan: Merancang sistem energi yang efisien dan berkelanjutan.

Dengan kemampuannya untuk menangani masalah yang kompleks dan menemukan solusi yang mendekati optimal, Algoritma Genetika menjadi alat yang sangat berguna di berbagai bidang industri. 

program genetic algorithm menggunakan bahasa java dan menampilkan chart

import org.jfree.chart.ChartFactory;

import org.jfree.chart.ChartUtils;

import org.jfree.chart.JFreeChart;

import org.jfree.chart.plot.PlotOrientation;

import org.jfree.data.xy.XYSeries;

import org.jfree.data.xy.XYSeriesCollection;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import java.util.Random;

public class GeneticAlgorithm {

    private int populationSize;

    private int chromosomeLength;

    private int maxGenerations;

    private double mutationRate;

    private Random random;

    private XYSeries fitnessSeries;

    public GeneticAlgorithm(int populationSize, int chromosomeLength, int maxGenerations, double mutationRate) {

        this.populationSize = populationSize;

        this.chromosomeLength = chromosomeLength;

        this.maxGenerations = maxGenerations;

        this.mutationRate = mutationRate;

        this.random = new Random();

        this.fitnessSeries = new XYSeries("Best Fitness");

    }

    public double optimize() {

        // Initialize population

        List<boolean[]> population = initializePopulation();

        int generation = 0;

        double[] fitness = evaluatePopulation(population);

        double bestFitness = getBestFitness(fitness);

        while (generation < maxGenerations && bestFitness > 0) {

            List<boolean[]> newPopulation = new ArrayList<>();

            for (int i = 0; i < populationSize; i++) {

                boolean[] parent1 = selectParent(population, fitness);

                boolean[] parent2 = selectParent(population, fitness);

                boolean[] offspring = crossover(parent1, parent2);

                mutate(offspring);

                newPopulation.add(offspring);

            }

            population = newPopulation;

            fitness = evaluatePopulation(population);

            bestFitness = getBestFitness(fitness);

            fitnessSeries.add(generation, bestFitness);

            generation++;

        }

        return bestFitness;

    }

    private List<boolean[]> initializePopulation() {

        List<boolean[]> population = new ArrayList<>();

        for (int i = 0; i < populationSize; i++) {

            boolean[] chromosome = new boolean[chromosomeLength];

            for (int j = 0; j < chromosomeLength; j++) {

                chromosome[j] = random.nextBoolean();

            }

            population.add(chromosome);

        }

        return population;

    }

    private double[] evaluatePopulation(List<boolean[]> population) {

        double[] fitness = new double[populationSize];

        for (int i = 0; i < populationSize; i++) {

            boolean[] chromosome = population.get(i);

            fitness[i] = evaluateChromosome(chromosome);

        }

        return fitness;

    }

    private double evaluateChromosome(boolean[] chromosome) {

        // Implement your fitness function here

        // This function should return the fitness value of the given chromosome

        // The fitness value represents the quality of the solution

        // Lower values indicate better solutions

        // Example: Counting ones

        int count = 0;

        for (boolean gene : chromosome) {

            if (gene) {

                count++;

            }

        }

        return count;

    }

    private boolean[] selectParent(List<boolean[]> population, double[] fitness) {

        int index = rouletteWheelSelection(fitness);

        return population.get(index);

    }

    private int rouletteWheelSelection(double[] fitness) {

        double totalFitness = 0;

        for (double fit : fitness) {

            totalFitness += fit;

        }

        double randomValue = random.nextDouble() * totalFitness;

        double cumulativeFitness = 0;

        for (int i = 0; i < fitness.length; i++) {

            cumulativeFitness += fitness[i];

            if (cumulativeFitness >= randomValue) {

                return i;

            }

        }

        return fitness.length - 1;

    }

    private boolean[] crossover(boolean[] parent1, boolean[] parent2) {

        boolean[] offspring = new boolean[chromosomeLength];

        int crossoverPoint = random.nextInt(chromosomeLength);

        for (int i = 0; i < crossoverPoint; i++) {

            offspring[i] = parent1[i];

        }

        for (int i = crossoverPoint; i < chromosomeLength; i++) {

            offspring[i] = parent2[i];

        }

        return offspring;

    }

    private void mutate(boolean[] chromosome) {

        for (int i = 0; i < chromosomeLength; i++) {

            if (random.nextDouble() < mutationRate) {

                chromosome[i] = !chromosome[i];

            }

        }

    }

    private double getBestFitness(double[] fitness) {

        double bestFitness = Double.MAX_VALUE;

        for (double fit : fitness) {

            if (fit < bestFitness) {

                bestFitness = fit;

            }

        }

        return bestFitness;

    }

    public void createChart(String outputFileName) {

        XYSeriesCollection dataset = new XYSeriesCollection();

        dataset.addSeries(fitnessSeries);

        JFreeChart chart = ChartFactory.createXYLineChart(

                "Genetic Algorithm", "Generation", "Best Fitness",

                dataset, PlotOrientation.VERTICAL, true, true, false);

        try {

            ChartUtils.saveChartAsPNG(new File(outputFileName), chart, 800, 600);

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

    public static void main(String[] args) {

        int populationSize = 50;

        int chromosomeLength = 20;

        int maxGenerations = 100;

        double mutationRate = 0.01;

        GeneticAlgorithm ga = new GeneticAlgorithm(populationSize, chromosomeLength, maxGenerations, mutationRate);

        double bestFitness = ga.optimize();

        System.out.println("Best Fitness: " + bestFitness);

        ga.createChart("output_chart.png");

    }

}

In this implementation, the Genetic Algorithm attempts to optimize a binary chromosome represented as a boolean array. You can modify the evaluateChromosome() method to define your own fitness function based on your problem requirements.

The createChart() method generates an XYLineChart using the JFreeChart library to plot the best fitness value over generations. The resulting chart is saved as a PNG image file.

You can customize the parameters and fitness function according to your needs. To use the JFreeChart library, include the JFreeChart JAR file in your project's dependencies.

When you run the program, it will print the best fitness value achieved by the Genetic Algorithm and save the output chart as "output_chart.png" in the current directory.

Feel free to modify the code further and customize it as per your requirements.