In the short space of just over a year we have had very important developments happening in AI technologies. One of the biggest leaps was by ChatGPT-3 which is a Generative Pre-trained Transformer model in AI technology. Now we have GPT-4 and GPT-5 is on the way. In public tests on text and Images, it is well known that Generative AI is a very creative technology. Generative AI is also called Generative Artificial Intelligence which is a subset of Deep learning in Artificial Intelligence. In reality all these seemingly magical technologies happen mostly thanks to a lot of math. In this post, we will create some very simple C++ code that learns from a given input and generates random outputs.
Table of Contents
What is AI? What is artificial intelligence?
Artificial Intelligence, also called AI refers to the simulation of human intelligence in machines that are programmed so they appear to think like humans and mimic their actions. The term may also be applied to any machine that exhibits traits associated with a human mind such as learning and problem-solving. (reference: Investopedia). If you want to learn more AI terms you can check this post below.
If you want to learn more about basic AI examples in C++ then please check our Artificial Intelligence Technologies category.
What is Generative Artificial Intelligence?
Generative artificial intelligence (generative AI, GenAI, or GAI) is an artificial intelligence technology that is used to generate text, images, videos, or other data by using generative models. Generative AI models learn from the given input and then generate new data that is similar to the given inputs.
Generative AI models are learned by the given inputs (such as text, images, or datasets) and then trained with these inputs by a generative model, then they can generate new output examples. Generative AI models are capable of generating new content with or without any human instructions. Generally, a user gives simple instructions (which is called “prompt”) then it generates a new sample appropriate with these instructions and a trained data set. Here is a very simple Generative AI model which we will give an example below.
Some of the Generative AI models are; Generative Adversarial Networks (GANs), Variational Autoencoders (VAEs), Autoregressive models, and Transformers.
How can we create simple generative AI code in C++?
First, let’s create our simple Generative AI that can be trained by given text inputs and learn from it, that means it can be trained by given inputs. Then we can create a generator model to generate new sentences. Here we will have a class that has a map. This map will hold strings and related strings with each one. Let’s define our class and map as below,
|
1 2 3 4 5 6 7 8 9 |
class GenerativeAI { private: std::map<std::string, std::vector<std::string>> wordRel; // map to world releation public: } |
We can teach relations between words by adding them to a string vector. Note that, this is a very simple learning example. In real, generative AI models, you should consider more details and can be trained by the weights in different activation function models, more complicated professional models have more layers, biases, hidden neurons, filters, transformers, tensor models, and so on.
Let’s create a method that can learn from a given text in string types. Here is a learn_fromstring() method that can be added under the public section.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
// Method to learn word relations from a given string void learn_fromstring(const std::string &sentence) { std::istringstream iss(sentence); std::vector<std::string> tokens{ std::istream_iterator<std::string>{iss}, std::istream_iterator<std::string>{} }; for (size_t i = 0; i < tokens.size() - 1; ++i) { wordRel[tokens[i]].push_back(tokens[i + 1]); } } |
In our learn_fromstring() method above, we convert the sentence to istringstream, then we create a word (token) vector from this stream. Then we handle each word, and we push the next word to its mapped order. In an example, if we train “I am “, “I was”, and “I have” sentences it will add the “I” map and “am”, “was”, and “have” to this vector. In other words, it stores possible next words coming after the “I” word. In real these relations are made with word indexes, weights, activations functions, etc. For example “am” is generally used with “I”, so their relation is high, the weight coefficient between them should be higher. To make a simple example, we do not consider about weights and activations.
Now, we need a sentence generator under the public section that generates random text by considering the relation between words. First, let’s give our generator model example, and then we can explain.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// Method to generate a sequence of words based on learned relations std::string sentence_generator(const std::string &startWord, int length) { std::string currentWord = startWord; std::string sequence = currentWord; for (int i = 0; i < length - 1; ++i) { if (wordRel.find(currentWord) == wordRel.end()) break; std::vector<std::string> nextWords = wordRel[currentWord]; std::uniform_int_distribution<int> distribution(0, nextWords.size() - 1); currentWord = nextWords[distribution(generator)]; sequence += " " + currentWord; } return sequence; } |
Here above in the sentence_generator() method, we define the first word (you can store the first used words in a store, and you can choose randomly too) and the length of sentences to be generated wisely. Then we generate intermediate words of sentence in a loop. At the end, it will return the newly generated sequence sentence.
That’s it, very simple!
To understand what is happening inside this map, let’s create another method to print the word relations as below,
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// print the word releations void print_word_relations() { std::cout << "Word Relations:" << std::endl; for (const auto &pair : wordRel) { std::cout << pair.first << ":"; for (const auto &word : pair.second) { std::cout << " " << word; } std::cout << std::endl; } std::cout << std::endl; } |
Now we can develop our main function. Let’s create a new Generative AI object from this class, and we can train some sentences by using the learn_fromstring() method. Let’s print word relations after the learning process from given sentences. Then we can create many new sentences. We can use the sentence_generator() method to create a new string in each loop. Here is how we can train some sentences and generate 10 new sentences as an output.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
int main() { GenerativeAI generator; // Learn from sentences generator.learn_fromstring("I am generative AI test example"); generator.learn_fromstring("I was a code"); generator.learn_fromstring("I can develop applications in C++"); generator.learn_fromstring("I have a generative code example"); generator.learn_fromstring("I should generate different sentences"); generator.learn_fromstring("I am easy with LearnCPlusPlus.org"); // Print word releations that learnt generator.print_word_relations(); // Generate new sentences for (int i = 0; i < 10; ++i) { std::cout << "Generated Sentence " << i + 1 << ": " << generator.sentence_generator( "I", 4+rnd()%2 ) << std::endl; } system("pause"); return 0; } |
Is there a full example of simple generative AI code in C++?
Here is a full example of generative artificial intelligence using C++.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 |
#include <iostream> #include <map> #include <string> #include <vector> #include <sstream> #include <iterator> #include <algorithm> #include <random> std::random_device rnd; std::mt19937 generator(rnd()); class GenerativeAI { private: std::map<std::string, std::vector<std::string>> wordRel; // map to world releation public: // Method to learn word relations from a given string void learn_fromstring(const std::string &sentence) { std::istringstream iss(sentence); std::vector<std::string> tokens{ std::istream_iterator<std::string>{iss}, std::istream_iterator<std::string>{} }; for (size_t i = 0; i < tokens.size() - 1; ++i) { wordRel[tokens[i]].push_back(tokens[i + 1]); } } // Method to generate a sequence of words based on learned relations std::string sentence_generator(const std::string &startWord, int length) { std::string currentWord = startWord; std::string sequence = currentWord; for (int i = 0; i < length - 1; ++i) { if (wordRel.find(currentWord) == wordRel.end()) break; std::vector<std::string> nextWords = wordRel[currentWord]; std::uniform_int_distribution<int> distribution(0, nextWords.size() - 1); currentWord = nextWords[distribution(generator)]; sequence += " " + currentWord; } return sequence; } // print the word releations void print_word_relations() { std::cout << "Word Relations:" << std::endl; for (const auto &pair : wordRel) { std::cout << pair.first << ":"; for (const auto &word : pair.second) { std::cout << " " << word; } std::cout << std::endl; } std::cout << std::endl; } }; int main() { GenerativeAI generator; // Learn from sentences generator.learn_fromstring("I am generative AI test example"); generator.learn_fromstring("I was a code"); generator.learn_fromstring("I can develop applications in C++"); generator.learn_fromstring("I have a generative code example"); generator.learn_fromstring("I should generate different sentences"); generator.learn_fromstring("I am easy with LearnCPlusPlus.org"); // Print word releations that learnt generator.print_word_relations(); // Generate new sentences for (int i = 0; i < 10; ++i) { std::cout << "Generated Sentence " << i + 1 << ": " << generator.sentence_generator( "I", 4+rnd()%2 ) << std::endl; } system("pause"); return 0; } |
Here are the results:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
Word Relations: AI: test I: am was can have should am a: code generative am: generative easy applications: in can: develop code: example develop: applications different: sentences easy: with generate: different generative: AI code have: a in: C++ should: generate test: example was: a with: LearnCPlusPlus.org Generated Sentence 1: I was a code Generated Sentence 2: I have a generative Generated Sentence 3: I can develop applications Generated Sentence 4: I was a code example Generated Sentence 5: I am easy with LearnCPlusPlus.org Generated Sentence 6: I have a code example Generated Sentence 7: I am easy with LearnCPlusPlus.org Generated Sentence 8: I am generative code Generated Sentence 9: I was a generative code Generated Sentence 10: I was a generative AI |
I should note that I try to do as simple as it is, to make it understandable and easy to code. I tried to make about 20 different examples (including some support from Copilot) but finally, I found this is the most simple and easy generative AI model.
C++ Builder is the easiest and fastest C and C++ compiler and IDE for building simple or professional applications on the Windows operating system. It is also easy for beginners to learn with its wide range of samples, tutorials, help files, and LSP support for code. RAD Studio’s C++ Builder version comes with the award-winning VCL framework for high-performance native Windows apps and the powerful FireMonkey (FMX) framework for UIs.
There is a free C++ Builder Community Edition for students, beginners, and startups; it can be downloaded from here. For professional developers, there are Professional, Architect, or Enterprise versions of C++ Builder and there is a trial version you can download from here.
