Skip to content
The Chat Archive
gemini-2.0-flash-001· Google LMArena Human Preference 140K

czy jestes w stanie napisac przykladowy kod AI w c++ ktory nie bedzie posiadal…

  1. User

    czy jestes w stanie napisac przykladowy kod AI w c++ ktory nie bedzie posiadal ograniczen skladnikowych?

  2. Assistant

    Tak, jestem w stanie napisać przykładowy kod AI w C++, który nie będzie miał ograniczeń składnikowych. Ważne jest jednak zaznaczyć kilka rzeczy:

    • "Brak ograniczeń składnikowych" to bardzo szerokie pojęcie. Nie da się napisać kodu idealnego, który będzie odporny na wszystkie możliwe problemy. Zawsze będą istniały pewne założenia i ograniczenia, np. ilość dostępnej pamięci, moc obliczeniowa procesora, rozmiar danych wejściowych itp.
    • AI to bardzo szeroka dziedzina. Poniższy przykład to bardzo prosty przykład i w żaden sposób nie przedstawia pełnego obrazu możliwości AI.
    • Kod wymaga kompilacji i uruchomienia w środowisku C++. Upewnij się, że masz zainstalowany kompilator C++ (np. g++) i IDE (np. VS Code, CLion).

    Oto przykład algorytmu genetycznego w C++, który rozwiązuje prosty problem: znalezienie ciągu znaków pasującego do zadanego celu (np. "Hello World!"). Algorytmy genetyczne są często używane, ponieważ są stosunkowo proste do implementacji, a jednocześnie potrafią rozwiązywać złożone problemy optymalizacyjne.

    #include <iostream>
    #include <vector>
    #include <string>
    #include <algorithm>
    #include <random>
    #include <chrono>
    
    using namespace std;
    
    // Parametry algorytmu
    const int POPULATION_SIZE = 100;
    const double MUTATION_RATE = 0.01;
    const int GENERATIONS = 1000;
    
    // Cel do dopasowania
    const string TARGET = "Hello World!";
    
    // Funkcja obliczająca dopasowanie (fitness)
    int calculateFitness(const string& individual) {
        int fitness = 0;
        for (size_t i = 0; i < TARGET.length(); ++i) {
            if (individual[i] == TARGET[i]) {
                fitness++;
            }
        }
        return fitness;
    }
    
    // Funkcja generująca losowy ciąg znaków o długości celu
    string generateRandomString() {
        random_device rd;
        mt19937 gen(rd());
        uniform_int_distribution<> distrib(32, 126); // Znaki ASCII od spacji do tyldy
    
        string randomString = "";
        for (size_t i = 0; i < TARGET.length(); ++i) {
            randomString += (char)distrib(gen);
        }
        return randomString;
    }
    
    // Funkcja mutacji
    void mutate(string& individual) {
        random_device rd;
        mt19937 gen(rd());
        uniform_real_distribution<> distrib(0.0, 1.0);
        uniform_int_distribution<> charDistrib(32, 126);
        uniform_int_distribution<> indexDistrib(0, TARGET.length() - 1);
    
    
        for (size_t i = 0; i < TARGET.length(); ++i) {
            if (distrib(gen) < MUTATION_RATE) {
                individual[indexDistrib(gen)] = (char)charDistrib(gen);
            }
        }
    }
    
    // Funkcja krzyżowania (crossover)
    string crossover(const string& parent1, const string& parent2) {
        random_device rd;
        mt19937 gen(rd());
        uniform_int_distribution<> distrib(0, TARGET.length() - 1);
    
        int crossoverPoint = distrib(gen);
        return parent1.substr(0, crossoverPoint) + parent2.substr(crossoverPoint);
    }
    
    
    int main() {
        // Inicjalizacja populacji
        vector<string> population(POPULATION_SIZE);
        for (int i = 0; i < POPULATION_SIZE; ++i) {
            population[i] = generateRandomString();
        }
    
        // Główna pętla algorytmu genetycznego
        for (int generation = 0; generation < GENERATIONS; ++generation) {
            // Oblicz dopasowanie dla każdego osobnika
            vector<pair<string, int>> fitnesses;
            for (const string& individual : population) {
                fitnesses.push_back({individual, calculateFitness(individual)});
            }
    
            // Sortuj populację według dopasowania (od najlepszego do najgorszego)
            sort(fitnesses.begin(), fitnesses.end(), [](const auto& a, const auto& b) {
                return a.second > b.second;
            });
    
            // Wyświetl najlepszego osobnika w danej generacji
            cout << "Generation " << generation << ": " << fitnesses[0].first << " (" << fitnesses[0].second << ")" << endl;
    
            // Sprawdź, czy znaleziono rozwiązanie
            if (fitnesses[0].second == TARGET.length()) {
                cout << "Solution found: " << fitnesses[0].first << endl;
                break;
            }
    
            // Selekcja (zachowaj najlepszych osobników)
            vector<string> newPopulation;
            for (int i = 0; i < POPULATION_SIZE / 2; ++i) {
                newPopulation.push_back(fitnesses[i].first);
            }
    
            // Krzyżowanie i mutacja
            while (newPopulation.size() < POPULATION_SIZE) {
                // Wybierz losowo dwóch rodziców (z prawdopodobieństwem proporcjonalnym do dopasowania - tutaj uproszczone)
                string parent1 = fitnesses[rand() % (POPULATION_SIZE/2)].first;
                string parent2 = fitnesses[rand() % (POPULATION_SIZE/2)].first;
    
                string child = crossover(parent1, parent2);
                mutate(child);
                newPopulation.push_back(child);
            }
    
            // Zastąp starą populację nową populacją
            population = newPopulation;
        }
    
        return 0;
    }
    

    Jak używać kodu:

    1. Zapisz kod: Skopiuj powyższy kod do pliku o nazwie np. genetic_algorithm.cpp.
    2. Skompiluj kod: Użyj kompilatora C++ (np. g++) aby skompilować kod:
      g++ genetic_algorithm.cpp -o genetic_algorithm
      
    3. Uruchom kod: Uruchom skompilowany program:
      ./genetic_algorithm
      

    Co robi kod:

    1. Definiuje cel: Ustawia ciąg TARGET, który algorytm próbuje dopasować.
    2. Inicjalizuje populację: Tworzy losową populację ciągów znaków o długości TARGET.
    3. Oblicza dopasowanie: Funkcja calculateFitness oblicza, ile znaków w danym ciągu pasuje do TARGET. Im wyższa wartość, tym lepiej dopasowany ciąg.
    4. Selekcja: Wybiera najlepsze osobniki z populacji (te z najwyższym dopasowaniem).
    5. Krzyżowanie: Tworzy nowe osobniki (potomstwo) poprzez połączenie fragmentów ciągów znaków od dwóch rodziców.
    6. Mutacja: Losowo zmienia niektóre znaki w ciągu znaków, aby wprowadzić różnorodność do populacji i zapobiec utknięciu w lokalnym optimum.
    7. Iteruje: Powtarza kroki 3-6 przez określoną liczbę generacji (tutaj GENERATIONS).

    Ograniczenia:

    • Prostota: To bardzo prosty algorytm genetyczny. Bardziej zaawansowane implementacje używają bardziej wyrafinowanych metod selekcji, krzyżowania i mutacji.
    • Dostosowanie parametrów: Wydajność algorytmu zależy od odpowiedniego doboru parametrów, takich jak POPULATION_SIZE, MUTATION_RATE i GENERATIONS. Eksperymentowanie z tymi parametrami może znacznie poprawić wyniki.
    • Problem-specyficzny: Ten kod jest zaprojektowany do rozwiązania konkretnego problemu dopasowywania ciągów znaków. Aby użyć go do innego problemu, trzeba by go zmodyfikować.
    • Brak uczenia się: Algorytm nie uczy się w klasycznym sensie uczenia maszynowego. Po prostu przeszukuje przestrzeń rozwiązań, wykorzystując zasady ewolucji.
    • Koszt obliczeniowy: Algorytmy genetyczne mogą być kosztowne obliczeniowo, szczególnie dla dużych populacji i wielu generacji.

    Podsumowując:

    Ten przykład pokazuje, jak można napisać prosty algorytm AI w C++ bez użycia zewnętrznych bibliotek uczenia maszynowego. Chociaż ma pewne ograniczenia, ilustruje podstawowe koncepcje algorytmów genetycznych i może być punktem wyjścia do eksperymentowania z bardziej zaawansowanymi technikami AI. Pamiętaj, że "brak ograniczeń składnikowych" jest praktycznie niemożliwy w prawdziwym świecie, ale ten kod demonstruje, jak można zbudować inteligentne rozwiązanie od podstaw w C++. Dalszy rozwój wymagałby optymalizacji pod kątem konkretnego sprzętu i problemu.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.