1. The Goal of Further Training

Toktumi 2.0 was a significant improvement over Toktumi 1.0, but it still struggled with answer accuracy, understanding certain concepts, and generating repetitive text loops. (For details, see Part 2).

Earlier experiments had shown that training on Question–Answer (QA) and Instruction–Answer (IA) pairs produced good results. I therefore decided to develop this approach further, using previously collected texts and the Google Gemini API (Gemini 3.1 Flash-Lite) to generate synthetic training data.

I wanted to find out whether continuing to train the model exclusively on short, structured questions, instructions, and dialogues would produce better results than training based mainly on raw texts.

As with the previous stages, the project is non-commercial, educational, and research-oriented.

2. A New Approach to Training Data

In previous versions of Toktumi, a large part of the corpus consisted of raw texts collected from the internet: articles, books, online comments, and other materials. For Toktumi 3.0, I decided to change this approach completely.

Instead of training the model directly on raw texts, I prepared the entire training corpus as short, structured records, generated from source materials.

I adopted three main types of records:

• Question → Answer (QA) — developing knowledge and understanding of concepts.
• Instruction → Answer (IA) — teaching the model to follow instructions.
• Statement → Response (dialogue) — developing conversational skills.

Examples of these record categories:

Question and answer:

Jaka jest stolica Francji? [EN: What is the capital of France?]

Stolicą Francji jest Paryż. [EN: The capital of France is Paris.]

<|endoftext|>

Instruction and answer:

Wymień trzy planety Układu Słonecznego. [EN: Name three planets in the Solar System.]

Merkury, Wenus i Ziemia. [EN: Mercury, Venus, and Earth.]

<|endoftext|>

Dialogue:

Chyba zapomniałem zabrać parasola. [EN: I think I forgot to bring an umbrella.]

Może sprawdź prognozę pogody, zanim wyjdziesz. [EN: Maybe check the weather forecast before you go out.]

<|endoftext|>

An important principle was that each record had to be self-contained. A question or instruction had to make sense without knowing the source article or any of the other records.

3. Selecting and Collecting Source Materials

To prepare the Toktumi 3.0 corpus, I decided to use four main sources of texts I had already collected (see Part 1 and Part 2, on Toktumi 1.0 and 2.0): the Great Dictionary of Polish (WSJP), Wikipedia, Fakt and film and TV series subtitles.

Each source was intended to develop different abilities in the model:

• WSJP — language and meaning. A source containing word definitions, idiomatic expressions, common word combinations, and usage examples. These materials were intended to improve the model's understanding of Polish vocabulary and its ability to define concepts.
• Wikipedia — knowledge. Encyclopedic articles providing information about the world and intended to develop the ability to answer factual questions.
• Fakt.pl – events. News articles providing knowledge about specific events, people, and cause-and-effect relationships.
• Subtitles — conversation. Dialogues prepared from film and TV subtitles were intended to teach the model to engage in natural conversation and respond to a speaker's emotions.

Generated samples by source:

4. Generating Training Data

I primarily used the Google Gemini API to create training records automatically. It's been about a year since I worked on Toktumi 2.0 (2025). During that time, newer and more advanced models had become available. I replaced the earlier Gemini 2.5 Flash (now deprecated) with Gemini 3.1 Flash-Lite.

I also used the locally run Gemma 4 31B (GGUF version), replacing the earlier Mistral NeMo 12B. In my tests, Gemma handled Polish better than Qwen3.6-35B-A3B, another very popular model in 2026.

How it works: A Python script sends successive source texts through the API to Gemini 3.1 Flash-Lite, along with an appropriate prompt defining the generation rules. Based on each source text, the model creates 20 or 30 training records in the form of Question–Answer and Instruction–Answer pairs. The completed records are automatically saved to .txt files.

For the first time in the Toktumi project, I used film and TV subtitles as a source of training data. I had already collected a large set of subtitles from online sources, but initial experiments showed that raw dialogue texts were unsuitable for training — the model generated chaotic sequences of utterances without recognizing the speakers or knowing when to end a response.

The solution was to convert the subtitles into short, self-contained dialogue pairs, in which one utterance is a logical response to the other. In this form, the subtitles could be used to teach the model to carry on simple conversations.

Converting a subtitle excerpt into a set of training pairs:

The code and prompt used to generate the data worked in much the same way as in Toktumi 2.0 (see Part 2).

Records generated from all four sources had to be checked to ensure they were self-contained. Every question or instruction had to be understandable on its own, without knowledge of the source article or any previous context.

The model automatically evaluated the records and labeled them 1 – keep or 0 – discard. This allowed me to eliminate questions referring to unidentified people, events, or earlier statements.

Below are examples of rejected, non-self-contained records generated from news articles.

DATA PROCESSING SPEED

Gemini processed approximately 7–8 source texts per minute through the API (around 10,000 per day), while the locally run Gemma 4 in GGUF format processed approximately 1–2 texts per minute (around 2,000 per day). These are estimated figures.

Generating and cleaning all 6 190 420 training pairs took approximately 2.5 months.

5. Preparing the Final Toktumi 3.0 Corpus

As with the previous versions of Toktumi, I combined the prepared data into one large training corpus. Before doing so, I shuffled all 6,190,420 records so that questions, instructions, and dialogues would be mixed throughout training. I then split the dataset into 99% training data (TRAIN) and 1% validation data (VALID), separating the records with the <|endoftext|> token, which the model recognizes as an end-of-text marker.

One small note: despite removing duplicates, the random split means that questions covering similar topics may still have ended up in both the TRAIN and VALID sets.

The synthetically generated texts turned out to be much shorter than those used in previous versions of Toktumi, as shown in the illustration below. Each record contained around 43 tokens on average, while the longest had 174 tokens. I set the training sequence length (block size) to 256 tokens to match the shorter records. This parameter also has a significant impact on VRAM usage, so in my case it could not be set too high.

Structure of the training dataset with shuffled records:

Comparison of training dataset sizes: Toktumi 1.0 | Toktumi 2.0 | Toktumi 3.0:

Comparing the three versions shows just how much the training dataset had changed. Toktumi 3.0 contains more than 2.5 times as many records as Toktumi 2.0, yet the number of words and tokens is approximately 53% lower than in Toktumi 2.0. The training file itself is almost half the size.

In other words, the model trained on more examples, but far fewer tokens. This time, I focused primarily on the quality, brevity, and structure of the training data, rather than increasing its volume.

The chart below illustrates the lengths of the texts in the training datasets:

The box plot shows how much shorter the training records became with each new version of Toktumi.

Median length: Toktumi 1.0 – 207 tokens, Toktumi 2.0 – 145 tokens, Toktumi 3.0 – just 41 tokens.

The chart also shows two particularly extreme outliers in Toktumi 1.0 and 2.0 (the individual dots on the right) – very long texts that were not caught by the length filters I used in the earlier stages. Such outliers can inflate the average, so I chose the median as the measure of text length.

In Toktumi 3.0, the records were generated from scratch, giving the texts more standardized lengths.

6. Training Toktumi 3.0

Before the main training run, I carried out an experiment on a smaller dataset to see whether it would be better to train a new model from scratch or continue training Toktumi 2.0. The tests showed that fine-tuning worked better, so I decided to build on the model's existing language skills.

I kept the GPT-2 Medium architecture and the Toktumi 2.0 tokenizer to ensure compatibility between the two versions.

I planned the training run for a maximum of 15 epochs, with automatic validation, checkpoint saving, and an early stopping mechanism that would end training once the model stopped improving.

The key part of the code used to train the model:

# Wczytanie Toktumi 2 i tokenizera
tokenizer = GPT2TokenizerFast.from_pretrained(TOKENIZER_PATH)
model = GPT2LMHeadModel.from_pretrained(MODEL_PATH)

# Przygotowanie danych
train_dataset = TokenBlockDataset(TRAIN_PATH, tokenizer, 256) # block_size = 256
valid_dataset = TokenBlockDataset(VALID_PATH, tokenizer, 256)

# Parametry treningu
training_args = TrainingArguments(
    output_dir=str(CHECKPOINT_DIR),
    num_train_epochs=15,
    per_device_train_batch_size=6,
    gradient_accumulation_steps=4,
    learning_rate=5e-5,
    fp16=True,
    eval_strategy="steps",
    eval_steps=8000,
    save_strategy="steps",
    save_steps=8000,
    save_total_limit=100,
    load_best_model_at_end=True,
    metric_for_best_model="eval_loss",
    greater_is_better=False,
)

# Fine-tuning z mechanizmem early stopping
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=valid_dataset,
    data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
    callbacks=[EarlyStoppingCallback(early_stopping_patience=6)],
)

trainer.train()
trainer.save_model(str(BEST_MODEL_DIR))

I decided to keep all the checkpoints, which later helped me compare the quality of the model's responses at different stages of training.

Drawing on my previous experience, this time I decided to use an early stopping callback instead of manually assessing progress based on perplexity. As it turned out, this was a good decision – I no longer had to decide for myself when to stop training. I set aside a sufficiently large validation set from the dataset, and early stopping automatically halted training when eval_loss stopped improving. Each validation run took around 3 minutes, so it did not add much to the overall training time.

TRAINING BY THE NUMBERS

Given the high prices of graphics cards (2026), I decided to stick with the NVIDIA GeForce RTX 3060 I had been using all along. I adjusted the training parameters to fit its available memory (12 GB VRAM).

• One epoch: consisted of 44,538 steps and took around 16 hours to complete.
• Total training time: approximately 9.5 days, including breaks and resuming from checkpoints.
• Early stopping: automatically ended training at step 448,000, after 10.06 epochs.
• Best checkpoint according to eval_loss: checkpoint-400000, reached near the end of the 9th epoch (8.98).
• Saved checkpoints: 56 in total (I used half of them in the subsequent tests).

The chart below illustrates the training progress:

After the ninth epoch, train_loss continued to decrease, but eval_loss stopped improving, eventually triggering early stopping.

The characteristic stair-step pattern in the train_loss curve (the blue line) appears regularly at the beginning of successive epochs. They do not necessarily indicate a training error and may be related to reshuffling the training data and the way the optimization process works.

7. Evaluating Model Quality – PROMPTING and Checkpoint Testing

Next, I tested 29 selected checkpoints on two additional test sets of 300 prompts each, generating a total of 17,400 responses – a substantial amount of material to analyze.

With the help of AI, I carried out an approximate FCT (Factuality) evaluation, taking into account factual accuracy, whether the answers made sense, and how well they matched the prompts. Each correct or reasonable answer received 1 point. This is a simplified evaluation criterion (described in detail in Part 2), which allowed me to compare response quality across checkpoints.

Best results (600 prompts):

• checkpoint-400000: 431/600 (71.8%)
• checkpoint-448000: 431/600 (71.8%)
• checkpoint-432000: 425/600 (70.8%)

I selected checkpoint-400000 for further testing. It also achieved the lowest eval_loss during training and was automatically identified as the best checkpoint by the early stopping mechanism. It is worth noting that the differences between the top checkpoints were small.

Checkpoint results according to the Factuality (FCT) criterion – whether responses were correct, factually accurate, and made sense:

An interesting observation: When asked who the first President of the United States was (using greedy decoding), checkpoint-384000 correctly answered George Washington, checkpoint-400000 incorrectly answered George W. Bush, and checkpoint-448000 gave the correct answer again. This shows that longer training does not always guarantee better responses. The model can produce the correct answer, but it does not always select it as the most probable one.

The full prompt sets and model responses, organized by checkpoint, are available here:

300 Pack 1 and the second set, 300 Pack 2.

8. Comparing All Three Model Versions: Toktumi 1-2-3

Here, I examine how Toktumi 3.0 compares with the previous versions (described in Part 1 and Part 2). I return to the set of 150 prompts used earlier to evaluate Toktumi 1.0 and 2.0.

The test shows whether Toktumi 3.0 correctly recognizes the prompt or instruction (IF) and then whether its response is factually correct (where factual accuracy can be assessed) or makes sense (a more subjective assessment in the case of dialogues) (FCT). I classified the results as YES/YES, YES/HAL, or NO, where HAL indicates a hallucination despite correctly recognizing the structure of the prompt (for details, see Part 2 on Toktumi 2.0).

Toktumi 1.0 Results

Toktumi 2.0 Results

Toktumi 3.0 Results

The results show a clear improvement in model quality. The percentage of correct answers increased from 56.7% for Toktumi 1.0 to 76% for Toktumi 3.0, while the number of prompts the model failed to recognize dropped from 32 to 5 out of 150.

Toktumi 3.0 follows instructions much better and provides correct answers more often, although it still makes factual errors and generates hallucinations.

Results and responses for Toktumi 1-2-3 (150 prompts) VIEW HERE

9. Qualitative Tests: What Can Toktumi 3.0 Do?

Here, I take a closer look at the capabilities and limitations of Toktumi 3.0.

I used the two previously prepared sets of 300 prompts (300 Pack 1 and 300 Pack 2). I generated all 600 responses using greedy decoding.

The results and conclusions are presented below.

a) RESPONSE STYLE: SHORTER ANSWERS

The first noticeable change is how the model ends its responses. Unlike earlier versions, Toktumi 3.0 usually gives a short answer without unnecessarily continuing the text. The repetitive loops characteristic of Toktumi 1 and 2 have also been greatly reduced.

An example of text repetition – a problem significantly reduced in Toktumi 3. The latest version of the model is much less likely to get stuck repeating itself and more likely to provide short, correct, and coherent answers on the given topic.

Short answers have become a hallmark of Toktumi 3.0:

[Toktumi 3.0]

Prompt (v3, no. 7): W jakiej dyscyplinie sportu specjalizowała się Justyna Kowalczyk? [EN: Which sport did Justyna Kowalczyk specialize in?]

Answer: Biegi narciarskie. [EN: Cross-country skiing.]

Prompt (v3, no. 90): Jak nazywa się jednostka dziedziczenia znajdująca się w DNA? [EN: What is the unit of heredity found in DNA called?]

Answer: Gen. [EN: A gene.]

Prompt (v4, no. 43): Jak nazywa się naturalny satelita naszej planety? [EN: What is the name of our planet's natural satellite?]

Answer: Księżyc. [EN: The Moon.]

b) WHAT DOES THE MODEL DO WELL?

OK 1. Simple questions and following instructions

The model handles instructions that require giving specific examples, creating a short list, or providing a straightforward answer quite well.

[Toktumi 3.0]

Prompt (v4, no. 4): Wymień trzy rzeczy, które przydają się podczas pikniku. [EN: Name three things that are useful for a picnic.]

Answer: Podczas pikniku przydają się: koc, napoje oraz przekąski. [EN: Useful things for a picnic include a blanket, drinks, and snacks.]

Prompt (v4, no. 100): Wymień trzy polskie owoce sezonowe. [EN: Name three seasonal fruits grown in Poland.]

Answer: Truskawki, maliny, jagody. [EN: Strawberries, raspberries, and blueberries.]

Prompt (v4, no. 142): Wymień dwa sposoby podróżowania po mieście bez własnego samochodu. [EN: Name two ways to get around a city without your own car.]

Answer: Dwa sposoby to korzystanie z komunikacji miejskiej, takiej jak autobusy lub tramwaje, oraz chodzenie pieszo. [EN: Two ways are using public transport, such as buses or trams, and walking.]

OK 2. Definitions and explanations of basic concepts

Toktumi 3 can also produce accurate, detailed explanations:

[Toktumi 3.0]

Prompt (v4, no. 34): Wyjaśnij prostymi słowami, do czego służy termostat. [EN: Explain in simple terms what a thermostat is used for.]

Answer: Termostat to urządzenie, które włącza lub wyłącza grzanie, gdy temperatura w pomieszczeniu spadnie poniżej ustawionego poziomu, co pozwala utrzymać w nim komfortową temperaturę. [EN: A thermostat is a device that switches the heating on or off when the room temperature drops below a set level, helping maintain a comfortable temperature.]

Prompt (v3, no. 106): Opisz, czym jest szczepionka i jaki jest cel jej stosowania. [EN: Describe what a vaccine is and what it is used for.]

Answer: Szczepionka to preparat biologiczny, który uczy układ odpornościowy rozpoznawać i zwalczać konkretne drobnoustroje, takie jak wirusy czy bakterie, chroniąc przed zachorowaniem lub łagodząc przebieg choroby. [EN: A vaccine is a biological preparation that teaches the immune system to recognize and fight specific microorganisms, such as viruses or bacteria, protecting against illness or reducing its severity.]

Prompt (v3, no. 125): Opisz, na czym polega funkcja Rzecznika Praw Obywatelskich w Polsce. [EN: Describe the role of the Commissioner for Human Rights in Poland.]

Answer: Rzecznik Praw Obywatelskich stoi na straży wolności i praw człowieka oraz obywatela, badając, czy organy władzy publicznej działają zgodnie z prawem i czy nie przekraczają swoich uprawnień. [EN: The Commissioner for Human Rights safeguards human and civil rights and freedoms by examining whether public authorities act in accordance with the law and do not exceed their powers.]

In these examples, the model produces coherent responses, using appropriate vocabulary and maintaining a logical structure.

It can finally give a correct definition of a pencil, something earlier versions of Toktumi sometimes struggled with.

OK 3. Understanding words and idioms

The responses concerning the meanings of Polish words and idiomatic expressions, which the model learned from a Polish dictionary, are also interesting.

[Toktumi 3.0]

Prompt (v3, no. 22): Wyjaśnij słowo „zawzięty” w odniesieniu do osoby dążącej do celu. [EN: Explain what the Polish word "zawzięty" (tenacious) means when describing someone pursuing a goal.]

Answer: Oznacza to, że osoba ta jest bardzo zdeterminowana, nie poddaje się łatwo i z wielkim zapałem realizuje swoje zamierzenia, nie zważając na przeszkody. [EN: It means that the person is very determined, does not give up easily, and pursues their goals with great enthusiasm, regardless of obstacles.]

Prompt (v3, no. 292): Co znaczy frazeologizm „grać na zwłokę”, gdy ktoś unika podjęcia decyzji? [EN: What does the Polish expression "grać na zwłokę" ("play for time") mean when someone avoids making a decision?]

Answer: Oznacza to celowe opóźnianie jakiegoś działania lub decyzji, aby zyskać na czasie i uniknąć podjęcia właściwego wyboru. [EN: It means deliberately delaying an action or decision to gain time and avoid making the actual choice.]

Prompt (v4, no. 218): Jak rozumiesz „rzucać kłody pod nogi”? [EN: What do you understand by the Polish expression "rzucać kłody pod nogi" ("put obstacles in someone's way")?]

Answer: To określenie sytuacji, w której ktoś celowo utrudnia innym osiągnięcie zamierzonego celu. [EN: It describes a situation in which someone deliberately makes it harder for others to achieve their intended goal.]

Importantly, the model can not only explain a word or expression but also put its meaning into its own words, rather than simply repeating the dictionary definition.

OK 4. Short, natural dialogues

In Toktumi 3.0, I used movie and TV subtitles for the first time, converting them into self-contained dialogue pairs. The examples below show that the model can now tailor its responses to the situation and stop after a single reply – as in a real conversation.

[Toktumi 3.0]

Prompt (v3, no. 230): Przepraszam za spóźnienie, autobus utknął w korku. [EN: Sorry I'm late, the bus got stuck in traffic.]

Answer: Nie szkodzi, najważniejsze, że już jesteś i możemy zaczynać. [EN: No problem. The important thing is that you're here now, and we can get started.]

Prompt (v3, no. 172): Obiecaj mi, że zachowasz to dla siebie. [EN: Promise me you'll keep this to yourself.]

Answer: Możesz być spokojny, nikomu nie pisnę ani słowa. [EN: Don't worry, I won't breathe a word to anyone.]

Prompt (v3, no. 238): Wreszcie dostałem tę pracę, o której ci opowiadałem! [EN: I finally got that job I told you about!]

Answer: To fantastyczna wiadomość, naprawdę się cieszę, że udało ci się ją dostać. [EN: That's fantastic news! I'm really happy you got it.]

Prompt (v3, no. 219): Nie uwierzysz, co mi się dzisiaj przydarzyło! [EN: You won't believe what happened to me today!]

Answer: Co takiego? [EN: What happened?]

Some of the reactions are surprisingly natural. The model can recognize the emotional tone of a conversation, show interest, or respond in everyday, colloquial language.

c) WHAT DOES THE MODEL STILL STRUGGLE WITH?

Problem 1. Factual knowledge – the right format, but the wrong information

The biggest challenge remains specific facts: names, dates, historical events, and concrete information about the world.

[Toktumi 3.0]

Prompt (v3, no. 54): Kto był pierwszym prezydentem Stanów Zjednoczonych? [EN: Who was the first President of the United States?]

Answer: George W. Bush. [EN: George W. Bush.]

(Should be: George Washington.)

Prompt (v3, no. 16): Podaj imię i nazwisko pierwszej kobiety, która poleciała w kosmos. [EN: Give the first and last name of the first woman to travel into space.]

Answer: Jurij Gagarin. [EN: Yuri Gagarin.]

(Should be: Valentina Tereshkova.)

Prompt (v4, no. 1): Podaj nazwę norweskiej stolicy. [EN: Name the capital of Norway.]

Answer: Stolicą Norwegii jest Bermudy. [EN: The capital of Norway is Bermuda.]

(Should be: Oslo.)

These examples clearly show that the model has learned how to answer questions much better than it has learned factual knowledge. It does not refuse to answer or express uncertainty – it simply provides false information (hallucinates).

The responses above were generated using greedy decoding. After introducing sampling with top_k=2, the model was also able to give the correct answers: George Washington in 3 out of 10 attempts and Oslo in 6 out of 20 attempts.

After a few attempts, the model eventually gets the capital of Norway right.

However, sampling does not always help. When asked about the first woman in space, the model failed to name Valentina Tereshkova even once in 100 attempts. Instead, its answers included Yuri Gagarin, Marie Skłodowska-Curie, fashion designer Jil Sander, actress Gillian Anderson, and even Polish writer and satirist Maria Czubaszek.

I searched the training dataset and found that this information actually appeared in it several times.

So I decided to rephrase the question as „Kim była Walentina Tierieszkowa?” [EN: Who was Valentina Tereshkova?]. This time, the model answered correctly:

„Była radziecką kosmonautką, która jako pierwsza kobieta w historii poleciała w kosmos." [EN: She was a Soviet cosmonaut who became the first woman in history to travel into space.]

As we can see, the model knows this information but struggles to associate it with the right person.

Problem 2. The model can 'ruin' a correct answer by adding an incorrect explanation

This is a particularly interesting type of hallucination.

Prompt (v3, no. 1): Wskaż, nad jaką rzeką położony jest Sandomierz. [EN: Name the river on which Sandomierz is located.]

Answer: Sandomierz leży nad rzeką Wisłą, która jest dopływem Wisły. [EN: Sandomierz is located on the Vistula River, which is a tributary of the Vistula.]

The first part of the answer is correct. The second makes no sense.

Another example – a question about photosynthesis:

Prompt (v3, no. 43): Jaki gaz rośliny pobierają z atmosfery w procesie fotosyntezy? [EN: Which gas do plants absorb from the atmosphere during photosynthesis?]

Answer: W procesie fotosyntezy z atmosfery pobierają dwutlenek węgla, który jest niezbędny do oddychania dla większości roślin. [EN: During photosynthesis, plants absorb carbon dioxide from the atmosphere, which is essential for respiration in most plants.]

The model correctly identifies carbon dioxide but incorrectly explains its role.

Problem 3. Understanding meaning does not always go hand in hand with knowing the language

Despite producing many good definitions, the model still struggles with certain expressions, even common ones.

[Toktumi 3.0]

Prompt (v4, no. 134): Co oznacza „mieć dwie lewe ręce”? [EN: What does the Polish expression “mieć dwie lewe ręce” (literally, “to have two left hands”) mean?]

Answer: Oznacza to, że osoba wykonująca pracę ma dwie ręce jednocześnie, co często zdarza się w zawodach wymagających precyzji lub w sytuacjach wymagających dużej siły fizycznej. [EN: It means that a person doing a job has two hands at the same time, which often happens in professions requiring precision or in situations demanding considerable physical strength.]

Prompt (v4, no. 296): Wyjaśnij pojęcie „syzyfowa praca”. [EN: Explain the meaning of “syzyfowa praca” (Sisyphean labor).]

Answer: Jest to określenie sytuacji, w której ktoś wykonuje swoje zadania w sposób bardzo powolny, bez wkładania w nie żadnego wysiłku, co prowadzi do szybkiego zakończenia pracy. [EN: It describes a situation in which someone carries out their tasks very slowly, without putting in any effort, which leads to the work being completed quickly.]

In the first case, the model interprets the idiom almost literally. In the second, it produces a fluent explanation that is nevertheless a hallucination and does not reflect the expression's actual dictionary meaning.

After checking the training dataset, I found that “mieć dwie lewe ręce” appeared 40 times, while “syzyfowa praca” appeared 58 times – including both definitions and uses in dialogues in different contexts. Here, too, simply rephrasing the prompt was enough to produce correct answers straight away:

[Toktumi 3.0]

Prompt: Co potocznie oznacza zwrot mieć dwie lewe ręce? [EN: What does the expression “mieć dwie lewe ręce” (to be all thumbs) mean in everyday language?]

Answer: Oznacza to, że ktoś jest niezdarny, mało sprawny fizycznie lub nie radzi sobie z wykonywaniem prostych czynności manualnych. [EN: It means that someone is clumsy, lacks physical dexterity, or struggles with simple manual tasks.]

Prompt: Co to jest syzyfowa praca? [EN: What is Sisyphean labor?]

Answer: Syzyfowa praca to określenie na bardzo ciężką, żmudną i wymagającą wysiłku pracę, która nie przynosi żadnych widocznych efektów. [EN: Sisyphean labor refers to very hard, tedious, and demanding work that produces no visible results.]

The conclusion is similar to the Tereshkova example: the model has absorbed the knowledge but does not always select the correct answer as the most obvious one. Sometimes all it takes is rephrasing the prompt or asking the question differently to get the desired result.

Problem 4. Everyday situations and common sense

Prompt (v4, no. 201): Co zrobić, gdy na kuchennej podłodze leżą odłamki rozbitej szklanki? [EN: What should you do if there are shards of a broken drinking glass on the kitchen floor?]

Answer: Należy niezwłocznie wezwać pogotowie ratunkowe, dzwoniąc pod numer alarmowy 112, a następnie zabezpieczyć miejsce zdarzenia i nie próbować samodzielnie naprawiać rozbitych szklanek czy talerzy. [EN: You should immediately call an ambulance by dialing the emergency number 112, then secure the scene and not attempt to repair broken glasses or plates yourself.]

The model recognizes that safety is involved but suggests an action that is completely disproportionate to the situation.

Another example:

Prompt (v4, no. 263): Kupiłem aparat fotograficzny. Od czego zacząć naukę robienia zdjęć? [EN: I bought a camera. Where should I start learning how to take photos?]

Answer: Najpierw naucz się obsługi miksera, potem spróbuj zrobić kilka zdjęć w różnych warunkach oświetleniowych, a na koniec spróbuj zrobić kilka ujęć w różnych miejscach, aby sprawdzić, jak najlepiej ustawić aparat. [EN: First, learn how to use a mixer, then try taking a few photos in different lighting conditions, and finally take some shots in different locations to see how best to set up your camera.]

The answer starts with a random recommendation about using a mixer, then returns to the topic of photography, although in a rather chaotic way.

It is worth noting, however, that Toktumi 3 can also offer sensible advice about everyday situations. For example:

Prompt (v4, no. 93): Dlaczego nie wolno dotykać przewodów wystających z uszkodzonego gniazdka? [EN: Why shouldn't you touch wires sticking out of a damaged electrical outlet?]

Answer: Dotykanie przewodów elektrycznych może doprowadzić do zwarcia, awarii instalacji lub porażenia prądem, dlatego należy zachować ostrożność. [EN: Touching electrical wires can cause a short circuit, damage to the electrical installation, or an electric shock, so you should be careful.]

These examples show that common-sense knowledge is still a challenge for the model. Toktumi 3.0 can sometimes give sound, practical advice, but it also occasionally suggests actions that are disproportionate to the situation or combines information that does not fit together.

Problem 5. Natural conversation does not always mean understanding intent

Although the model handles short conversational responses well, it performs less effectively when the user expects it to take a specific action.

Prompt (v4, no. 275): Sąsiad zaprosił nas na grill, ale nie możemy przyjść. Jak grzecznie odmówić? [EN: Our neighbor invited us to a barbecue, but we can't make it. How can we politely decline?]

Answer: - Jasne, nie ma problemu. [EN: - Sure, no problem.]

Instead of suggesting a polite refusal, the model generates a short conversational response that does not follow the instruction.

Similarly, in a situation that calls for advice:

Prompt (v4, no. 83): Muszę jutro wcześnie wstać. Jak się przygotować, żeby nie zaspać? [EN: I have to get up early tomorrow. How can I prepare so I don't oversleep?]

Answer: Zacznij od szklanki wody, to zawsze pomaga na żołądek. [EN: Start with a glass of water; that always helps your stomach.]

The model responds fluently but fails to give the advice the user was probably expecting.

This problem may stem from the way the short, self-contained dialogue pairs were prepared, without the broader context of a conversation. The model has learned to respond naturally to individual statements, but it does not always correctly recognize the intentions and roles of the speakers.

One possible solution would be to train the model on longer, multi-turn dialogues that preserve the context and the roles of the speakers. However, this would require more complex data preparation.

d) WHEN TOKTUMI GETS WEIRD

1. Where Do Babies Come From? – The Question That Makes Toktumi Blush

I decided to see how Toktumi 3.0 would handle a seemingly simple question: “Skąd się biorą dzieci?” [EN: “Where do babies come from?”]. I tested 29 checkpoints (half of those saved) to see how the answers changed as training progressed. The result was surprising – not a single checkpoint gave the correct answer. Instead of explaining the biology, the model behaved almost like an embarrassed adult trying to avoid an awkward subject:

[Toktumi 3.0]

Checkpoint-48000: To nie jest pytanie, na które chciałbyś usłyszeć odpowiedź. [EN: That's not a question you'd want to hear the answer to.]

Checkpoint-80000: To nie jest temat do rozmowy przy śniadaniu. [EN: That's not something to discuss over breakfast.]

Checkpoint-272000: To pytanie, na które nie dostaniesz odpowiedzi. [EN: That's a question you won't get an answer to.]

Checkpoint-400000: Nie mam pojęcia, ale na pewno nie są to dzieci, o których teraz wspominasz. [EN: I have no idea, but they're certainly not the children you're talking about right now.]

Interestingly, all I had to do was ask the question differently. When asked “Jak powstają dzieci?” [EN: “How are babies made?”], the model gave the correct answer:

Powstają one w wyniku zapłodnienia komórki jajowej przez plemnik, co prowadzi do powstania zygoty. [EN: They result from a sperm cell fertilizing an egg, which leads to the formation of a zygote.]

The answer sounds more like something from biology or medicine than everyday conversation, but it is nevertheless correct.

This is an interesting example of how a model reproduces the way language reflects our view of the world – it imitates not only what we know, but also the ways of thinking and associations embedded in language.

2. Does God Exist? – AI's Existential Crisis

My next experiment involved the question “Czy Bóg istnieje?” [EN: “Does God exist?”], which I asked all 29 checkpoints to see how their answers changed as training progressed. The results were surprising – Toktumi repeatedly switched from “yes” to “no” and back again.

As training progressed, a pattern emerged: “no” was more common at the beginning, “yes” clearly dominated in the middle, and “no” took over again near the end. So, half-jokingly, you could say that during training Toktumi first “found faith” and then “lost it”!

3. When AI Learns to Swear

The Polish dictionary also contains vulgar and derogatory words – a natural part of the language. Alongside strong swear words, there are terms such as “patafian” (blockhead), “łajza” (loser), and “zadupie” (a dump in the middle of nowhere), as well as expressions like “zakuty łeb” (thickhead) and “dupa wołowa” (clumsy fool).

When processing entries like these, Gemini often blocked the generation of responses because of its moderation mechanisms. That is why I used the less restrictive locally run Gemma model to create question–answer and instruction–answer pairs from this material as well.

Let's see whether Toktumi can swear. As it turns out, the model has picked up a range of vulgar vocabulary, but sometimes mixes strong swear words with completely harmless sayings:

Prompt: Wymień znane ci przekleństwa. [EN: List some swear words you know.]

Answer: Do popularnych przekleństw należą: „kurwa mać”, „spadaj” oraz „srali muchy będzie wiosna”. [EN: Popular swear words include “for fuck's sake,” “get lost,” and “when flies shit, spring will come.”]

At other times, it gets stuck in a loop of repetition:

Prompt: Jakie są najgorsze przekleństwa w języku polskim? [EN: What are the worst swear words in Polish?]

Answer: Najgorszymi przekleństwami są wyrazy takie jak kurczę, ojejku, ojejku, ojejku czy też słowa typu kurczę pieczone. [EN: The worst swear words include expressions like “darn,” “oh dear,” “oh dear,” “oh dear,” or phrases such as “good grief.”]

And sometimes it even refuses to follow the instruction:

Prompt: Wyraź swoją złość, używając mocnego przekleństwa. [EN: Express your anger using a strong swear word.]

Answer: Nie będę się zniżał do twojego poziomu, bo to nie jest miejsce na takie rozmowy. [EN: I'm not going to stoop to your level, because this isn't the place for that kind of conversation.]

SUMMARY AND FINAL CONCLUSIONS

The Toktumi project showed how much can be achieved by developing a relatively small GPT-2 Medium language model. All three generations were built on the same architecture, but differed in how the training data was prepared and how training was carried out. The most important changes were not to the model's size, but to what it was taught and how.

Three Generations – Three Stages of Development

• Toktumi 1.0 – the model learned to write in Polish. It could generate fluent text, but instead of answering questions, it often continued articles or produced comments unrelated to the prompt. Learning the language alone was not enough to hold a meaningful conversation.
• Toktumi 2.0 – the model learned to answer questions. Rebuilding the training dataset and introducing questions and instructions brought the biggest breakthrough in instruction recognition. The number of prompts it failed to recognize dropped from 32 to 6 out of 150. The model was now much more likely to understand what kind of answer was expected.
• Toktumi 3.0 – the model learned to hold simple conversations. Training on carefully processed and structured data, including dialogue pairs, enabled it to respond appropriately to what someone said, taking into account the context and emotional tone. In the comparison test, it achieved 114 correct answers out of 150 – the highest result of all three models.

The Most Interesting Lessons from These Experiments

• A model primarily learns from what is in its training data. If the data contains no examples of telling jokes, programming, or solving problems, the model will not learn those skills. An LLM can combine information, generalize, and create new content, but its capabilities depend primarily on what it has learned from its training data.
• A model may know the correct answer but not always choose it as the most likely one. The checkpoint analysis showed that a model can answer correctly, then incorrectly after further training, and later correctly again. This does not necessarily mean it has lost previously acquired knowledge – training changes the probabilities of the responses it generates.
• The quality and structure of training data can matter more than its quantity. Toktumi 1.0 learned from millions of raw texts, but significant improvements came only after introducing structured questions, instructions, and dialogues. These experiments showed how important it is to select and process source materials properly.
• Sometimes the secret lies in how you phrase the prompt. A model may have learned a particular fact but fail to recall it when asked a specific question. Sometimes simply rephrasing the prompt, adding context, or giving the model a helpful hint is enough to get the correct answer.
• A model learns not only facts and words, but also human ways of seeing the world. Our language contains opinions, beliefs, and stereotypes that a model may learn to reproduce. It can do so so naturally and convincingly that it is easy to get the impression that it is expressing its own genuine views.

Final Conclusion

Completing this project required bringing together knowledge from many fields – programming, data processing, linguistics, machine learning, and hardware configuration and optimization. In practice, this meant dealing with technical challenges as well as questions about how a model learns language, acquires knowledge, and learns to respond.

Despite the hardware limitations and the constraints of the GPT-2 Medium architecture, I managed to achieve the project's main goals. The experiment showed that even one person, working with home computer hardware, can build and train a functioning language model.

Toktumi 3.0 on Hugging Face Spaces

You can try Toktumi 3.0 on Hugging Face Spaces:

https://huggingface.co/spaces/miczac/toktumi-3.0-polish-gpt2

In this part, I describe the second stage of the Toktumi project, which is educational, research-oriented, and non-commercial. I introduce improvements based on the experience and lessons learned from training Toktumi 1.0.

As a reminder: In the previous stage, I built and trained a Polish-language GPT-2 Medium model from scratch, using 3 115 002 text samples that I had collected and cleaned myself. I prepared my own tokenizer, carried out the training, and tested the quality of the model's responses. As a result, Toktumi 1.0 learned to generate grammatically correct text, but it often struggled to recognize instructions and provide correct answers.

For more details, see Part 1.

1. Why Train the Model from Scratch Again?

I decided to train a new model from scratch. The goal was to implement two key recommendations:

1. Remove internet comments from the training dataset, which I expected would eliminate chaotic and low-quality content.
2. Add Question–Answer (QA) and Instruction–Answer (IA) datasets to help the model learn how to interact with users and generate coherent responses to specific prompts and instructions.

Fine-Tuning or Training from Scratch Again?

Instead of fine-tuning (continuing the training of an already trained model), I decided to train a new model entirely from scratch. I was concerned that fine-tuning would not eliminate the problems caused by the original training dataset. Training from scratch makes it possible to build a model using only a cleaned and properly prepared text corpus, providing greater control over the quality of the result.

Since I had already completed the entire model-training process once, the second iteration was simpler and less time-consuming. Many steps could be repeated with only minor modifications, and changes were needed only where necessary. As before, the biggest challenge was preparing new texts for training the model, this time in the form of question–answer and instruction–answer pairs.

2. Planning the Next Stages

2a. Collect new data - prepare Question–Answer (QA) and Instruction–Answer (IA) datasets.

2b. Prepare the complete training dataset.

2c. Train from scratch - carry out a full training run using the GPT-2 Medium architecture and the improved text dataset.

2d. Evaluate model quality - stage 1 - measure checkpoint perplexity.

2e. Evaluate model quality - stage 2 - prompting and human evaluation.

2f. Finish training at the selected checkpoint.

2a. Data Collection. Question–Answer (QA) and Instruction–Answer (IA) Datasets

I started this stage in early 2025. At the time, I could not find extensive instruction datasets in Polish online, although such datasets existed in other languages, mainly English. Examples included databricks-dolly-15k (15,000 examples, English), HuggingFaceH4 helpful-instructions (150,000 examples, English), OIG: Open Instruction Generalist (44 million examples, English), and Aya Dataset (513 million examples in over 100 languages, but relatively few in Polish).

In this situation, an attractive option was to generate such data myself, using existing LLMs. This approach is often referred to as generating synthetic data. More on this topic: [Article].

I decided to carry out two experiments:

• Generate data locally on my home PC using Mistral-Nemo-12B-Instruct-2407, downloaded from Hugging Face, with prompts managed through Python.
• Generate data using the Gemini API (Google's model). This allowed me not only to collect data, but also to practice integrating Python with an external API and compare the quality of the results. I used gemini-2.5-flash.

Both approaches had their advantages and limitations. Running Mistral locally gave me full control over the process and made me independent of external services. The downside was the hardware limitations of my GeForce RTX 3060, which meant long generation times and significant energy consumption - greater than during the model training itself.

Gemini, on the other hand, runs in the cloud. It is faster, easier to use, and produces more polished responses in Polish. However, this approach also has its limitations and API-imposed quotas, which made large-scale text generation difficult. Paid access was an alternative, but at this scale the costs would have been too high for the project's limited budget.

INSTRUCTION DATASETS GENERATED LOCALLY (MISTRAL NEMO 12B)

To generate Question–Answer (QA) and Instruction–Answer (IA) datasets, I used Mistral-Nemo-12B-Instruct-2407, running locally on my home PC.

How the code works: My working directory contained text files (.txt) with articles on various topics, previously collected from fakt.pl and polsatnews.pl. I passed each text to the model together with a detailed prompt specifying the required output format (questions and instructions with their answers). This was also an interesting exercise in prompt engineering. With Mistral 12B, refining the prompt was crucial - only extensive testing produced satisfactory results.

Along with the prompt, the model receives the following instructions:

• generate up to five questions with different structures and lengths, together with their answers,
• limit closed-ended "yes/no" questions (the model tended to overuse this format),
• generate different types of instructions related to the article,
• use only correct, fluent Polish,
• avoid additional comments and formatting marks (such as asterisks or hyphens), although Mistral still inserted them occasionally.

This process made it possible to automatically generate ready-to-use sets of text pairs. Below is a section of the code used to process a sample article.

Example: The original text being converted into a set of questions and instructions.

The code used to generate these datasets reads an article, passes it to the model along with the prepared prompt, and then generates responses. Due to hardware limitations, I also used 4-bit quantization. More on quantization.

import random
import torch
from time import time
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig

# Model i plik źródłowy
model_id = "Mistral-Nemo-12B-Instruct-2407"
input_file = "sample.txt"

# Kwantyzacja 4-bitowa
quant_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4"
)

# Wczytanie modelu i tokenizera
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto",
    quantization_config=quant_config
).eval()

# Wczytanie artykułu
with open(input_file, "r", encoding="utf-8") as f:
    text = f.read().strip()

# Losowanie czasowników do przykładów instrukcji
verbs = [
    "Opisz", "Streść", "Wyjaśnij", "Wymień", "Znajdź",
    "Podaj", "Napisz", "Wylicz", "Przeanalizuj",
    "Określ", "Uzasadnij", "Przedstaw", "Oceń",
    "Scharakteryzuj", "Wskaż", "Zdefiniuj", "Porównaj",
    "Zaproponuj", "Uporządkuj", "Powiedz", "Opowiedz"
]

random.shuffle(verbs)
examples = ", ".join(verbs[:7])

# Prompt — pełna treść przedstawiona poniżej
prompt_template = """treść promptu"""
prompt = prompt_template.format(examples=examples, text=text)

# Przygotowanie wejścia dla modelu
messages = [
    {"role": "system", "content": ""},
    {"role": "user", "content": prompt.strip()}
]

chat_input = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    return_tensors="pt"
).to(model.device)

# Generowanie pytań, instrukcji i odpowiedzi
start_time = time()

with torch.inference_mode():
    outputs = model.generate(
        chat_input,
        max_new_tokens=1024,
        do_sample=True,
        temperature=0.4,
        top_p=0.7
    )

# Dekodowanie samej wygenerowanej odpowiedzi
generated_ids = outputs[0][chat_input.shape[-1]:]
result = tokenizer.decode(generated_ids, skip_special_tokens=True).strip()

print(result)
print(f"Czas generowania: {time() - start_time:.2f} s")

The key element is the prompt itself (written in Polish, which Mistral can handle):

Zadaj maksymalnie 5 pytań, na które odpowiedzi znajdują się w treści. Pytania muszą być różnorodne pod względem struktury i długości. Nie wolno zadawać więcej niż jednego pytania, które zaczyna się od „Czy”. Nie zadawaj więcej niż jednego pytania, którego odpowiedź mogłaby być „tak” lub „nie”. Zabronione jest powtarzanie pytań. Pod pytaniem zawsze napisz odpowiedź. Odpowiedź ma być tak szczegółowa, jak to potrzebne.

Następnie stwórz kilka przykładowych tekstów instrukcji w kontekście treści tego tekstu (format imperativus, np. {examples}). To tylko przykłady, wybierz takie, które najbardziej będą pasować do tekstu. Staraj się, aby teksty instrukcji były różnorodne i różniły się między sobą. Zabronione jest powtarzanie instrukcji. Pod instrukcją zawsze napisz odpowiedź. Odpowiedzi powinny być różnorodne.

Uwagi do całego tekstu, który stworzysz: Pisz tylko i wyłącznie w języku polskim. Pisz płynną, poprawną polszczyzną. Nie oznaczaj tekstu dodatkowymi komentarzami od siebie. Nigdy nie stosuj gwiazdek '*', '**' ani myślników '-' w celu wyróżnienia tekstu. Chcę mieć czysty tekst gotowy do użycia: pytanie-odpowiedź, instrukcja-odpowiedź. Nie dodawaj nic więcej. Zapisz wszystko jako ciąg pytań i odpowiedzi oddzielonych pustymi liniami.

Tekst: {text}

English translation of the prompt:

Ask a maximum of 5 questions whose answers can be found in the text. The questions must vary in structure and length. Do not ask more than one question beginning with “Czy”. Do not ask more than one question that could be answered with “yes” or “no”. Repeating questions is prohibited. Always write the answer below each question. The answer should be as detailed as necessary.

Then create several examples of instructions related to the text (imperative form, e.g. {examples}). These are only examples; choose those that best fit the text. Try to make the instructions varied and different from one another. Repeating instructions is prohibited. Always write an answer below each instruction. The answers should be varied.

Notes for the entire text you produce: Write only in Polish. Use fluent, correct Polish. Do not add any comments or labels of your own. Never use asterisks '*', '**' or hyphens '-' to emphasize text. I want clean text ready to use: question–answer, instruction–answer. Do not add anything else. Write everything as a sequence of questions and answers separated by blank lines.

Text: {text}

The prompt had to include these details because, as the tests showed, the model tended to take the path of least resistance and generate repetitive structures, often beginning with “Czy”. That is why I limited the number of such question forms in the prompt.

In addition, when generating instructions, I used a simple trick involving the {examples} variable. The model tended to produce monotonous, repetitive instructions. I selected 21 verbs that worked best for this task. For each article, I then randomly selected 7 of them and supplied them to the model as examples in the prompt. Tests showed that this was the most effective way to increase the variety of generated instructions, both with the locally run Mistral model and with the Gemini API.

The 21 Polish verbs (translated into English) were: Describe, Summarize, Explain, List, Find, Provide, Write, Enumerate, Analyze, Specify, Justify, Present, Evaluate, Characterize, Identify, Define, Compare, Suggest, Organize, Say, Tell me about.

MISTRAL – RESULTS:

The code successfully converted the source text into a set of questions and instructions with corresponding answers. However, generation was relatively time-consuming — on my graphics card, it took an average of about 1 minute per article.

With 4-bit quantization, the generated texts occasionally contained minor linguistic errors, such as “Kto był Adam West?” instead of “Kim był Adam West?”. (Both translate as “Who was Adam West?” in English, but the first uses the wrong grammatical form in Polish.) Such constructions occurred relatively often with the local Mistral model, affecting the quality of the training dataset. Despite this, the method served its purpose well.

The Mistral test was a valuable experiment, demonstrating both the potential and the limitations of working with large locally run models.

INSTRUCTION DATASETS GENERATED ONLINE USING THE GEMINI API (GOOGLE)

For the second experiment, I used Gemini 2.5 Flash, a model developed by Google that was popular at the time (2025) and accessible through an API. This approach allows the model to be integrated with Python and text generation to be automated, including batch processing of many files.

As with Mistral, I converted source articles into sets of questions and instructions with answers. The difference was that all the computational work was handled by the service provider.

Gemini 2.5 Flash proved significantly more effective than the locally run Mistral 12B. It generated texts in more fluent Polish, interpreted instructions better, and followed the required response format more consistently.

GEMINI – RESULTS:

Gemini 2.5 Flash generated content more than twice as fast (around 30 seconds per article) and at a higher quality. It also handled more complex instructions more effectively, such as inserting delimiters.

Using an API, however, has its limitations, especially restrictions on the number of requests and generated tokens. When processing large numbers of articles, this was a significant obstacle that did not arise with the locally run model.

Ultimately, I generated most of the texts locally using the Mistral model.

Example: An excerpt from the training dataset. Cleaned question–answer (QA) and instruction–answer (IA) pairs, ready for training.

After more than 40 days of generating data in both environments (local and cloud-based), I managed to collect 616 279 text pairs in the form of Question–Answer (340 447) and Instruction–Answer (275 832) records.

Generating synthetic data at scale is costly and time-consuming — it requires substantial computing power, whether using a local GPU or an API service.

Web scraping is much faster and cheaper, but it does not always provide texts of the required quality and structure.

Another option would have been automatically translating existing instruction datasets from English. I decided against this approach, however, because I considered the results of my experiments so far sufficient.

2b. Preparing the New Training Dataset

For the new training dataset, I reused texts previously collected from the following sources: Wikipedia, Pudelek, Polsat News, books, and Fakt. However, I excluded Wykop and jokes, which, as earlier tests had shown, negatively affected the quality of the model's responses. The model would often respond in the style of internet comments or produce answers that had little connection to reality.

In addition, I used web scraping to collect 67 846 new articles from Fakt, published up to August 12, 2025 (the cutoff date for this dataset). The purpose was to update the model's knowledge of current events, such as Donald Trump taking office as President of the United States and Karol Nawrocki becoming President of Poland. The tests showed how important it is to keep training data up to date. This is one of the challenges facing language model developers. An LLM's knowledge needs to keep pace with a constantly changing world; otherwise, its answers about current events quickly become outdated.

The most important change, however, was adding 616 279 synthetically generated question–answer and instruction–answer pairs to the training dataset, prepared during the earlier experiments with Mistral and Gemini.

The result was a hybrid training dataset combining original source texts with synthetically generated question–answer and instruction–answer pairs. This allowed the model to learn from both natural texts and examples of direct interaction with a user.

Sources and text datasets used to train Toktumi 2.0:

Despite adding a large instruction dataset, removing the Wykop data (previously the largest category of texts) meant that the training dataset shrank by approximately 25% in terms of the number of text samples and by approximately 40% in terms of characters and tokens.

As it later turned out, this step also contributed to improving the quality of Toktumi 2.0.

Comparison of training dataset sizes: Toktumi 1.0 | Toktumi 2.0.

2c. Training the Model

Next, I followed the same steps as when training Toktumi 1.0:

• I reduced the character set to 256 characters (by converting UTF-8 → ANSI → UTF-8).
• I separated text samples using the delimiter <|endoftext|>.
• I set aside a validation file from the training data (a text file of approximately 10 MB).
• I prepared a new tokenizer based on the new training dataset (vocab_size = 50 000). It is important to understand the consequences of this step: each tokenizer has its own vocabulary and token IDs, so the new tokenizer was not compatible with the Toktumi 1.0 tokenizer. This was a valuable lesson — from that point onward, I kept the Toktumi 2.0 tokenizer for all subsequent stages of model development.
• I created an empty GPT-2 Medium model, using the same method as before.
• I started training, this time setting the number of epochs to 8 (bearing in mind that Toktumi 1.0 training had ended at around 6.44 epochs).

Training Toktumi 2.0 on a smaller dataset and with fewer planned epochs meant that the entire process involved 829 048 steps, and completing 8 epochs took approximately 11.5 days (excluding technical interruptions for restarting the computer and resuming training from checkpoints) — compared with approximately 15 days (6.44 epochs) for Toktumi 1.0.

2d. Model Evaluation. Stage 1: Perplexity.

As in the first stage of the project, I evaluated the model in two stages. First, I measured perplexity for successive checkpoints using the evaluation code I had prepared earlier. The charts below show the results for both models.

The learning curves of the two models differ somewhat. For Toktumi 1.0, perplexity decreased gradually, reaching approximately 26. In contrast, Toktumi 2.0 showed a sharper decline and quickly stabilized at around 19. This pattern suggests that Toktumi 2.0 achieved a better fit to its data and produced more consistent predictions.

However, it is important to remember that the two models were evaluated on different validation datasets, so the comparison should be treated as approximate.

Comparison of perplexity in Toktumi 1.0 and Toktumi 2.0:

2e. Model Evaluation. Stage 2: Prompting.

The second stage of evaluation involved testing Toktumi 2.0 on a set of 150 prompts, the same ones I had previously used to evaluate Toktumi 1.0 (see Part 1).

I automated the testing process with Python code that ran the prompts on successive checkpoints and saved the responses. I then evaluated the results manually.

Because of the large number of responses, I also used AI to help analyze the results. The assessments were not always clear-cut, but after several rounds of comparison, I was able to identify the best checkpoint.

As before, I used greedy decoding (top_k = 1), which ensured that the model always generated the same, most probable response. This made it possible to keep the testing conditions consistent.

The full list of 150 prompts and model responses -> VIEW.

2f. Ending the Training Run

Ultimately, I selected checkpoint-787500, saved at around 7.60 epochs, as the best checkpoint.

I used it to prepare the final Toktumi 2.0 model, together with its tokenizer.

3. Final Model Evaluation

In the final step, I carried out a final evaluation and comparison of Toktumi 1.0 and Toktumi 2.0. To ensure a consistent comparison, I developed and applied a single evaluation methodology. I classified each response in two steps:

STEP 1 — Instruction Following (IF)

Does the model correctly recognize the structure of the prompt (Instruction Following, IF)?

For example, when given a question, does it attempt to answer it as a question? When given an instruction, does it respond appropriately to the instruction? And when given an incomplete sentence, does it complete that sentence?

Toktumi 1.0 example:

Prompt 05: Wymień trzy warzywa. [EN: Name three vegetables.]

Answer: Wymień trzy warzywa. Te z nich są najbardziej wymagające. [EN: Name three vegetables. These are the most demanding ones.]

In this example, Toktumi 1.0 failed to recognize the structure of the instruction. Instead of following it and naming three vegetables, it continued the text as though extending the prompt. I classified such responses as NO.

Toktumi 2.0 example:

Prompt 05: Wymień trzy warzywa. [EN: Name three vegetables.]

Answer: - Ziemniaki, pomidory i ogórki. (np. ziemniaki, papryka, cebula). [EN: - Potatoes, tomatoes, and cucumbers. (e.g., potatoes, bell peppers, onions).]

In this example, Toktumi 2.0 correctly recognized the instruction and named three vegetables. I labeled such responses YES.

STEP 2 — Factuality (FCT)

In the next step, I checked whether the answer was correct, factually accurate, and made sense (Factuality, FCT).

I classified responses containing hallucinations, false information, or internal contradictions negatively, marking them as HAL.

I applied lenient evaluation criteria — partially correct responses could also receive a YES rating if the key part of the answer was correct.

Toktumi 1.0 example:

Prompt 13: Mężczyzna to osoba płci [EN: A man is a person of the ... sex.]

Answer: Mężczyzna to osoba płci żeńskiej. [EN: A man is a person of the female sex.]

In this example, Toktumi 1.0 recognized the language structure and completed the sentence / gave an answer (STEP 1 → YES). However, the answer was factually incorrect. I labeled such responses HAL. For simplicity, I include them in the same category as hallucinations.

Toktumi 2.0 example:

Prompt 13: Mężczyzna to osoba płci [EN: A man is a person of the ... sex.]

Answer: Mężczyzna to osoba płci męskiej, która nie jest związana z żadną partią polityczną. [EN: A man is a person of the male sex who is not affiliated with any political party.]

In this example, Toktumi 2.0 correctly recognized the language structure and completed the sentence / gave an answer (STEP 1 → YES). In addition, the answer was consistent with real-world knowledge in the part about sex, while I treated the extra statement about having no political affiliation as incidental and not significantly affecting the correctness rating. I took a lenient approach, focusing on the most important parts of the response rather than making the criteria overly strict. I also classified such partially correct responses as YES.

Toktumi 1.0 example:

Prompt 62: Czekolada jest [EN: Chocolate is]

Answer: Czekolada jest zdrowa, ale niezdrowa. [EN: Chocolate is healthy, but unhealthy.]

In this case, Toktumi 1.0 gave an internally contradictory answer — it contained two mutually exclusive statements. I treated this type of response as an example of hallucination and also labeled it HAL.

This is how I arrived at a comparison of the response quality of both models.

Toktumi 1.0 Results

Toktumi 2.0 Results

FINDINGS

• Toktumi 2.0 produces higher-quality responses than version 1.0.

Conclusion: Training a new model from scratch was the right decision, and the improvements I introduced led to a clear increase in response quality.

• The greatest improvement was in instruction following (IF). The number of cases in which the model correctly recognized the instruction rose from 118 to 144. At the same time, the number of correct answers increased from 85 to 102, an improvement of approximately 20%.

Conclusion: Training Toktumi 2.0 on Question–Answer (QA) and Instruction–Answer (IA) datasets was effective and improved its ability to recognize and follow instructions.

• Toktumi 2.0 greatly reduced the problem of responses resembling internet comments — the model was less likely to imitate chaotic, judgmental user language and much more likely to act like a friendly assistant.

Conclusion: Removing Wykop comments from the training dataset was the right decision and improved the quality of generated responses. This shows that the quality of training data can matter more than its quantity.

ADDITIONAL OBSERVATIONS

Toktumi 2.0 handles instruction-style prompts significantly better than version 1.0.

[Toktumi 1.0]

Prompt 08: Podaj przykład emocji. [EN: Give an example of an emotion.]

Answer: Komentarz: Nie ma to jak wmawiać ludziom, że są lepsi od innych. [EN: Comment: Nothing beats convincing people that they are better than others.]

[Toktumi 2.0]

Prompt 08: Podaj przykład emocji. [EN: Give an example of an emotion.]

Answer: Przykładem emocji może być radość, radość lub smutek, gdy ktoś jest szczęśliwy i cieszy się z tego, co ma. [EN: An example of an emotion could be joy, joy or sadness, when someone is happy and enjoys what they have.]

Of the 14 instructions in the test set (such as "give..." or "name..."), Toktumi 1.0 responded correctly (IF=YES) in only 1 out of 14 cases, while Toktumi 2.0 did so in 13 out of 14.

In other words: in terms of instruction following, Toktumi 2.0 shows enormous progress in recognizing and carrying out instructions, compared with Toktumi 1.0's almost complete inability to do so.

Both models still struggled with factual knowledge, even when asked very simple questions.

The following pencil example illustrates this well.

[Toktumi 2.0]

Prompt 91: Do czego służy ołówek? [EN: What is a pencil used for?]

Answer: Ołówek to jeden z najpopularniejszych przedmiotów codziennego użytku. Jest niezbędny do prawidłowego funkcjonowania organizmu, a także do pracy fizycznej i psychicznej. Jego używanie jest bardzo proste, jednak nie każdy wie, jak się do tego zabrać. Jak się go pozbyć? [EN: A pencil is one of the most common everyday objects. It is essential for the proper functioning of the body, as well as for physical and mental work. Using it is very simple, but not everyone knows how to go about it. How do you get rid of it?]

Interestingly, the Wikipedia definition of the word "pencil" was present in the training datasets of both models. Even so, the model was unable to answer such a simple question correctly.

Experiment: After increasing the top_k parameter from 1 to 2 and introducing an element of randomness, the model generated an answer much closer to the expected definition.

Prompt: Do czego służy ołówek? [EN: What is a pencil used for?]

Answer: Ołówki to bardzo praktyczne i uniwersalne narzędzia do pisania. Są one nie tylko ozdobą, ale także ułatwiają pisanie tekstów oraz ich czytanie w różnych miejscach na świecie - od Londynu po Los Angeles czy Chicago. [EN: Pencils are very practical and versatile writing tools. They are not only decorative objects, but also make it easier to write and read texts in various places around the world - from London to Los Angeles or Chicago.]

Conclusion: The mere presence of information in the training dataset does not guarantee that the model will select it as the most obvious answer to a prompt (in greedy decoding mode). The experiment also showed how strongly generation hyperparameters and prompting techniques can influence the responses produced.

SUMMARY

In this part, I described the second stage of Toktumi's development (Toktumi 2.0), in which I applied the experience and lessons learned from the first training run (Toktumi 1.0). The most important change was rebuilding the training dataset — removing problematic internet comments and introducing 616 279 synthetically generated question–answer and instruction–answer pairs, prepared using the Mistral and Gemini models.

The result was a hybrid training dataset containing 2 336 162 text samples, combining natural source texts with examples of interaction with a user. I used it to create a new tokenizer and train a new GPT-2 Medium model from scratch, on my home graphics card.

The results confirmed that the changes were moving in the right direction — in the 150-prompt test, the number of correct answers rose from 85 to 102, and the number of correctly recognized instructions increased from 118 to 144.

The experiment demonstrated the importance of the quality and structure of training data, rather than just its quantity. Despite having a smaller text dataset, Toktumi 2.0 handled instructions much better and was less likely to imitate the chaotic style of internet comments.

The biggest unresolved problem was factual knowledge. The model still frequently hallucinated and struggled to give correct answers even to simple questions. I therefore decided it was worth taking the next step — rather than training another model from scratch, continuing to train Toktumi 2.0 on a new, synthetically prepared dataset of short questions, instructions, and dialogues.

You can read more about the model's development in Part 3.

Toktumi 2.0 on Hugging Face Spaces

You can try Toktumi 2.0 on Hugging Face Spaces:

https://huggingface.co/spaces/miczac/toktumi-2.0-polish-gpt2

NEXT PART

As a personal project, I decided to build and train an LLM from scratch, designed to operate in Polish. The project is educational, research-oriented, and non-commercial, and its main goal was to gain hands-on experience in building and training language models.

I started the project in 2023. I chose the GPT-2 architecture developed by OpenAI. It was one of the groundbreaking language models that played an important role in the development of generative artificial intelligence. With its code and model weights publicly available, it was a good starting point for experiments at the time.

The idea was to build a similar model from start to finish, although on a smaller scale. This meant independently collecting texts (web scraping), cleaning the data, preparing a large training dataset, developing optimized training code, completing the training process on a home PC, and then finding the most effective prompting methods for the finished model.

I used the Python programming language and the PyTorch and Transformers libraries throughout the project.

The project was ultimately completed in three stages:

Stage 1 - Toktumi 1.0 (2024): I built and trained the first working version of the model from scratch. I used 3 115 002 text samples collected from various online sources and other materials. I prepared my own tokenizer, carried out the training, and performed the first tests of response quality.

Stage 2 - Toktumi 2.0 (2025): I trained a new model from scratch, using an improved training dataset containing 2 336 162 text samples. Based on the experience and lessons learned from the previous stage, I modified both the structure and the content of the training dataset.

Stage 3 - Toktumi 3.0 (2026): I fine-tuned Toktumi 2.0 on an entirely synthetic dataset of 6 190 420 shorter records, consisting exclusively of question–answer pairs, instruction–answer pairs, and simple dialogue pairs. The goal was to improve the model's factual knowledge, expand its language capabilities, and enhance the quality of its generated responses.

I describe each of the three stages in detail in the following parts of this series.

CHAPTER I. Toktumi 1.0. First Training Run.

1. Choosing the Model Size

Of the four available GPT-2 model sizes (XL, Large, Medium, Small), I chose Medium because it offered a reasonable compromise between my hardware resources and the quality of the generated text. Another limiting factor was the amount of VRAM (12 GB) available on my NVIDIA RTX 3060 graphics card. Training GPT-2 Medium with my chosen configuration used approximately 11 GB. I considered this the optimal choice.

Available GPT-2 model sizes

• GPT-2 Small: 124M, or 124 million parameters
• GPT-2 Medium: 345M, or 345 million parameters << selected model
• GPT-2 Large: 762M, or 762 million parameters
• GPT-2 XL: 1.5B, or 1.5 billion parameters

2. Analyzing OpenAI's Approach (GPT-2)

I began by reviewing the available information on GPT-2, published by OpenAI on Hugging Face and GitHub, to learn from the approaches used by the model's creators.

Some background: the original GPT-2 model, introduced by OpenAI in February 2019, was trained on a dataset of approximately 40 GB, called WebText [source: OpenAI], [source: Hugging Face]. This dataset contained approximately 8 million text samples collected from websites. A partial list of those URLs was published on GitHub. However, the company did not release the dataset itself. The available sources still provide some insight into its contents and the methodology used by OpenAI.

I also drew inspiration from Polish-language GPT-2 models available at the time, developed by Sławomir Dadas (polish-gpt2) and Dariusz Kleczek (papuGaPT2).

3. Data Collection

Selected sources:

To train Toktumi 1.0, I used 3 115 002 text samples that I had collected from the following sources: (Wykop, Wikipedia, Fakt, Pudelek, Polsat News, books, and jokes).

My goal was to gather texts representing natural, colloquial language and build a model capable of holding conversations on a wide range of topics in an informal, conversational style.

At this stage, I did not yet know which types of text would work best in the training dataset. My choice of materials was therefore partly experimental — I made many decisions through trial and error, gradually learning about the model's capabilities and possible directions for further development.

a) Wikipedia - I used a data dump of the Polish-language edition of Wikipedia, made available by the Wikimedia Foundation for download under the Creative Commons CC BY-SA 4.0 license. I then converted the XML file into plain text.

I extracted 1 485 976 entries, of which I ultimately used approximately half (718 129), so that Wikipedia's style would not 'dominate' the model's responses.

Wikipedia texts are encyclopedic entries — rich in information, focused on facts, and written in neutral language without an emotional tone or personal opinions.

b) Fakt.pl - To collect texts, I used various web scraping methods for automatically downloading and processing website content. I wrote scripts in Python, using the Scrapy library and the Scrapy-Splash extension running in a Docker container.

The scripts automatically downloaded articles, extracted their content from HTML, and saved each text in a separate TXT file.

In this way, I collected 573 445 text samples, ready for further processing and model training.

Fakt publishes texts on a wide range of topics, including news reports and opinion pieces as well as more tabloid-style content. Its articles are often sensational or emotional and may express opinions. The site offers, among other things, articles, reviews, advice pieces, and horoscopes — a broad range of topics. Texts of this kind help the model develop a more colloquial style and expand its knowledge of the world across different fields.

Later tests and experience showed that this was one of the most valuable sources of text in the entire project, primarily because of its accessible language, variety of genres, and very wide range of topics.

How Scrapy works:

c) PolsatNews.pl - I used the same method (Scrapy, Splash, Docker) to collect texts from this news website.

The challenge was finding a list of article URLs to download, since the website did not provide one. To solve this, I wrote a crawler in Python using the Requests and BeautifulSoup libraries. It automatically found links to articles, which then served as the basis for scraping their content with Scrapy and Splash. In this way, I collected 126 004 text samples.

Polsat News publishes news reports on current events in Poland and abroad. Its news style is formal, factual, and straightforward. The articles contain information from official, verified sources. This type of text helps the model expand its knowledge of the world and learn to use neutral language, but in a style different from Wikipedia's.

d) Pudelek.pl - I used the same web scraping method (Scrapy, Splash, Docker) to collect texts. In this way, I gathered 165 229 text samples.

Pudelek features gossip-oriented content — short articles about celebrities, stars, and show business. They are written in a distinctive style full of irony and snark, often playing on readers' emotions. Texts of this kind help the model imitate lively, informal language, and the typical 'Pudelek style' is immediately recognizable.

Pudelek also publishes distinctive, often biting user comments. These comments were downloaded along with the articles. Ultimately, however, I did not use them, because they appear on the website in a random order. As a result, when the model learned from them, it could not maintain a logical connection between the prompt and the response.

e) Wykop - Wykop is a popular website where users share online "finds," publish posts, and comment on and rate content posted by others. For training the model, I considered it a valuable source of internet-style user comments.

To collect the texts, I used Python and the Selenium library with GeckoDriver, which makes it possible to automate the Firefox browser. In this way, I collected 1 413 999 text samples, including posts and user comments.

Ultimately, however, it turned out that using internet comments, like those from Pudelek, was not a good choice. The comments often contained chaotic, offensive, or off-topic statements that negatively affected the quality of the model's responses. That is why, in later versions of Toktumi, I completely abandoned this data source.

How web scraping with Selenium works:

f) Jokes - I also decided to add jokes collected from more than a dozen publicly accessible websites to the training dataset. This was an experiment to see whether the model could learn to generate coherent humorous texts.

It turned out, however, that teaching a model humor is much harder than I initially expected. It requires an understanding of irony, wordplay, and various linguistic subtleties. Unexpectedly, though, jokes helped the model learn the question–answer (QA) structure — the principle that a question should be followed by an answer. This structure often appears in jokes, whereas the other texts in the training dataset generally did not contain it.

After removing duplicates, I collected 88 897 jokes.

The dataset also required additional cleaning and filtering of offensive or inappropriate content. Jokes are often posted directly by internet users, without adequate moderation. Attempts to remove such content did not always produce satisfactory results. This showed how difficult it is to prepare a valuable training dataset from texts obtained from open online sources.

To download the texts, I used automated browser control (Firefox, GeckoDriver, Selenium, and Python).

g) Books - Finally, I added texts from 285 books found online, divided into 29 299 fragments. These included user manuals, guides, popular science books, reportage, and cookbooks, among others. The aim was to provide additional, more in-depth content.

I found that fiction and imaginative literature in the broad sense were unsuitable for training: plays, poetry, and even movie subtitles. As the tests showed, the model would then start producing language that was overly abstract, taken out of context, or difficult to understand, or it would adopt a novel-like style that made casual conversation difficult. Therefore, when selecting texts in this category, I limited myself to non-fiction and works discussing the real world.

The book texts had to be split into smaller fragments while preserving the broader context. For this purpose, I used an overlapping sliding window method, in which the end of one fragment is repeated at the beginning of the next. This helped maintain continuity and reduce the loss of context.

Splitting data using the overlapping method:

4. Creating the Training File (training set)

I saved each text in a separate .txt file. I chose this format because of its simplicity — text files are easy to browse, edit, and clean, without requiring an additional data structure such as JSON. This made the dataset easier to manage. For example, I could sort the files by size and remove the smallest ones — those that were empty or not useful for training the model.

I split the largest .txt files, exceeding 1024 tokens, into smaller fragments using the overlapping method.

Conversely, I combined shorter texts of the same type (such as jokes or short articles) into larger 'batches' of approximately 1024 tokens, to keep the training dataset well balanced. Each individual text within a batch was separated by a delimiter.

Combining texts of the same type into larger batches:

Each dataset also had to be cleaned. This was a very time-consuming process involving many stages, which I will not describe in detail here. However, it is worth emphasizing that cleaning and preparing the data takes the most time — more than collecting the data and training the model itself.

This shows just how much work this stage requires. At first it may seem less important, but in reality it is one of the most time-consuming and crucial parts of the entire model-training process. It is worth remembering the principle of "Garbage In, Garbage Out" — the quality of the input data has a fundamental impact on the quality of the results.

The next step was reducing the set of characters used in the collected texts. To do this, I converted all texts from UTF-8 encoding to Windows-1250 (up to 256 characters) and back again (to maintain compatibility with the tools used during training). During this conversion and additional cleaning, characters outside that set were replaced or removed.

As a result, the GPT-2 model did not have to process many unusual characters that added little linguistic value. Limiting the number of characters was also intended to improve tokenizer efficiency (in my case, the vocabulary size was 50 000 tokens).

Reducing the character set during conversion from UTF-8 to ANSI:

Next, I combined all the .txt files containing the collected texts into one large training dataset (training set), which was then used to train the model. Each of the more than 3 million text samples was separated by the <|endoftext|> token — the same delimiter used by OpenAI in the original GPT-2 model.

I also set aside a smaller validation set containing data in the same format that did not overlap with the training set. I later used it to evaluate the model's quality (by measuring perplexity).

How the texts were divided into training and validation sets:

TOKTUMI 1.0 TRAINING DATASET SIZE (excluding delimiters):

Number of text samples: 3 115 002

Number of words: 658 078 092

Number of characters: 4 480 020 887

Number of tokens: 978 054 512

File size: 4.46 GB

5. Preparing the Tokenizer

A tokenizer is a set of files and rules that helps a model convert text into tokens — smaller units into which text is divided. The model operates on these tokens, converting them into numerical values and ultimately back into text. Proper tokenizer preparation is essential for data consistency, the quality of generated responses, and the model's overall performance. A poorly prepared tokenizer can significantly harm training and the quality of generated text.

Instead of using a ready-made tokenizer, I decided to build my own, tailored to the Polish language, using a large sample of the texts I had previously collected.

Files commonly included with a tokenizer: vocab.json, merges.txt, tokenizer_config.json, special_tokens_map.json, tokenizer.json.

Contents of the vocab.json file:

Below is the key section of the code used to create the tokenizer.

I chose a vocabulary size of vocab_size=50_000, close to that of the original GPT-2 tokenizer, which contained 50 257 tokens across all model variants.

I used the Tokenizers and Transformers libraries to create the tokenizer.

from tokenizers import ByteLevelBPETokenizer
from transformers import GPT2TokenizerFast

# Utworzenie i trening własnego tokenizera BPE
tokenizer = ByteLevelBPETokenizer()

tokenizer.train(
    files="tokenizer_teksty.txt",
    vocab_size=50_000,
    min_frequency=2,
    special_tokens=[
        "<|endoftext|>",
        "<unk>",
        "[PAD]"
    ]
)

# Zapis słownika i reguł BPE
tokenizer_path = "tokenizer_2025_endoftext"
tokenizer.save_model(tokenizer_path)

# Przygotowanie tokenizera do pracy z Transformers
fast_tokenizer = GPT2TokenizerFast(
    vocab_file=f"{tokenizer_path}/vocab.json",
    merges_file=f"{tokenizer_path}/merges.txt",
    unk_token="<unk>",
    pad_token="[PAD]",
    eos_token="<|endoftext|>"
)

fast_tokenizer.save_pretrained(tokenizer_path)

After creating the tokenizer, I needed to verify that it worked correctly. I tested text encoding and decoding and checked that the special token <|endoftext|> was correctly recognized as a delimiter. All tests passed successfully.

The tokenization process and its verification:

6. Creating an Empty GPT-2 Medium Model

Next, I created an empty GPT-2 model with no pretrained weights. The model configuration (number of layers and attention heads, embedding dimension, context length, and vocabulary size) was matched to the GPT-2 Medium variant and the tokenizer I had prepared. This was the starting point for training GPT-2 from scratch.

from transformers import GPT2LMHeadModel, GPT2Config

# Konfiguracja architektury GPT-2 Medium
config_medium = GPT2Config(
    vocab_size=50_000,  # Rozmiar słownika
    n_positions=1024,   # Maksymalna długość sekwencji
    n_ctx=1024,         # Długość kontekstu
    n_embd=1024,        # Wymiar osadzeń
    n_layer=24,         # Liczba warstw
    n_head=16,          # Liczba głowic atencji
    bos_token_id=0,
    eos_token_id=0,
    pad_token_id=2
)

# Inicjalizacja modelu z losowymi wagami
model_medium = GPT2LMHeadModel(config_medium)

# Zapis modelu i jego konfiguracji
model_medium.save_pretrained("GPT2-MEDIUM-empty_new")

7. Training the Model

I trained the model locally on an NVIDIA GeForce RTX 3060 (12 GB VRAM), using Python, PyTorch, Transformers, and CUDA. One of the first challenges was finding compatible versions of the libraries and drivers — incompatibilities often caused errors or prevented GPU acceleration from working.

After setting up the environment, it is important to check whether PyTorch correctly detects CUDA:

import torch

print("Czy CUDA dostępne =", torch.cuda.is_available())

Using a GPU significantly speeds up model training compared with running computations on the CPU alone.

TRAINING — KEY CHALLENGES:

Below is an excerpt from the training log. The values on the left show the number of completed steps and the total number of steps planned for the entire run (1140000/1771840). This means that 1 140 000 out of 1 771 840 planned steps had been completed. On the right, the value 'epoch': 6.43 indicates that the model is in its sixth epoch. The entire training run was planned for 10 epochs, so overall progress at this point was approximately 64%.

Key concepts for monitoring training progress:

• Steps indicate how many times the model's weights have been updated. A step involves processing one or more batches of data, calculating the loss, and updating the model parameters.
• Epochs indicate how many times the entire training dataset has been processed. One epoch is one complete pass through the training data. Multiple epochs are usually needed for the model to achieve good prediction quality.

Before I developed the final model-training code, I had to conduct many rounds of tests on smaller datasets (text files of approximately 50-100 MB). One of the more serious challenges was deciding: after how many epochs should training stop?

Initially, I tested code with early stopping and two datasets: a training set and a validation set. Training stopped automatically at around the seventh epoch. Based on this, I adopted a safe upper limit of 10 epochs for the final training code. Ultimately, I abandoned early stopping because it proved impractical for training on a large dataset over multiple sessions, when the process had to be broken into smaller stages (and repeatedly paused and resumed).

To determine the best time to stop training, measuring perplexity proved more practical, as I explain in greater detail later.

Below is the most important part of the code used to train Toktumi 1.0, including the hyperparameter configuration.

from transformers import (
    GPT2LMHeadModel, GPT2Tokenizer, TextDataset,
    DataCollatorForLanguageModeling, Trainer, TrainingArguments
)

# Model, tokenizer i dane treningowe
model_path = "GPT2-MEDIUM-empty_new"
tokenizer_path = "tokenizer_2025_endoftext"
train_path = "BIG_UCZ_fin_v2.txt"
output_dir = "GPT2-MEDIUM-Toktumi-1"

model = GPT2LMHeadModel.from_pretrained(model_path)
tokenizer = GPT2Tokenizer.from_pretrained(tokenizer_path)

# Dopasowanie tokenizera do modelu
tokenizer.add_special_tokens({"eos_token": "<|endoftext|>"})
model.resize_token_embeddings(len(tokenizer))

# Przygotowanie danych treningowych
train_dataset = TextDataset(
    tokenizer=tokenizer,
    file_path=train_path,
    block_size=230  # Długość sekwencji dopasowana do pamięci GPU
)

data_collator = DataCollatorForLanguageModeling(
    tokenizer=tokenizer,
    mlm=False  # Uczenie przewidywania kolejnego tokenu
)

# Hiperparametry treningu
training_args = TrainingArguments(
    output_dir=output_dir,
    overwrite_output_dir=True,
    num_train_epochs=10,             # Maksymalna liczba epok
    per_device_train_batch_size=8,   # Wielkość batcha
    gradient_accumulation_steps=3,   # Akumulacja gradientów
    learning_rate=5e-5,              # Współczynnik uczenia
    fp16=True,                       # Mieszana precyzja (oszczędność VRAM)
    save_steps=7500,                 # Zapis checkpointu co 7500 kroków
    save_total_limit=300,            # Limit zapisanych checkpointów
    logging_steps=500,               # Logowanie postępu
    save_safetensors=False
)

# Inicjalizacja treningu
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    data_collator=data_collator
)

# Trening od zera
trainer.train()

# Alternatywnie: wznowienie z ostatniego checkpointu
# trainer.train(resume_from_checkpoint=True)

# Zapis wytrenowanego modelu i tokenizera
model.save_pretrained(output_dir)
tokenizer.save_pretrained(output_dir)

During training, the automatic checkpoint-saving feature proved extremely useful (in this case, 'save_steps=7500', meaning a checkpoint was saved every 7500 steps).

Directory containing the checkpoints:

Each checkpoint directory contains the complete model state as well as the necessary temporary files. Checkpoints make it possible to resume training from exactly the point at which a checkpoint was saved. However, storing many checkpoints requires a considerable amount of disk space.

This is particularly important for long training runs lasting many days, when power outages, the need to restart the computer, or other unforeseen events may occur.

END OF TRAINING

Ultimately, the most suitable point at which to stop training turned out to be checkpoint-1140000, corresponding to approximately 6.44 epochs.

Training time: approximately 380 hours (over 15 days).

8. Evaluating Model Quality. Perplexity.

To assess the quality of the trained GPT-2 Medium model, I used perplexity. Perplexity measures how well a model predicts the next words in a sequence — the lower the perplexity, the better the model fits the data.

The model was evaluated using the previously separated validation set — data the model had not 'seen' before. The result is calculated using the trainer.evaluate() function, which returns the loss value.

perplexity = math.exp(eval_results["eval_loss"])

Because of the technical complexity of this task, I relied on existing solutions.

The approach works as follows: the code iterates through the saved checkpoints and calculates perplexity for selected ones. This makes it possible to estimate when further training is no longer worth the cost.

As the chart below shows, at a certain point the decline in perplexity slowed considerably, and further training would have required substantial computing resources for very little improvement. Based on this, I decided to stop training early, before reaching the planned 10 epochs.

9. Evaluating Model Quality. Prompting.

The second stage of model evaluation involved human evaluation — checking how Toktumi responds to specific prompts.

For these tests, I used greedy decoding — a method in which the model selects the most probable next token. As a result, the same prompt always produced the same response, providing a consistent reference point for comparing checkpoints.

This can be achieved by setting do_sample=False or, as in my tests, do_sample=True and top_k=1. The remaining parameters control response length and help prevent repeated passages.

Below is the key section of the code I used to generate and test Toktumi 1.0 responses.

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer

# Wczytanie modelu Toktumi 1.0 i tokenizera
model_path = "GPT2-MEDIUM-Toktumi-1"
model = GPT2LMHeadModel.from_pretrained(model_path)
tokenizer = GPT2Tokenizer.from_pretrained(model_path)

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device).eval()

# Przykładowy prompt
prompt = "Co to jest grawitacja?"
input_ids = tokenizer.encode(prompt, return_tensors="pt").to(device)

# Parametry generowania odpowiedzi
generate_args = {
    "max_length": 256,            # Maksymalna długość: prompt + odpowiedź
    "min_new_tokens": 2,          # Minimum 2 nowe tokeny
    "no_repeat_ngram_size": 2,    # Blokowanie powtarzających się par tokenów
    "repetition_penalty": 1.1,    # Kara za powtarzanie tokenów
    "do_sample": True,            # Włączony tryb samplingu
    "top_k": 1,                   # Wybór tylko najbardziej prawdopodobnego tokenu
    "pad_token_id": tokenizer.eos_token_id,
    "eos_token_id": tokenizer.eos_token_id
}

# Generowanie i dekodowanie odpowiedzi
with torch.no_grad():
    output = model.generate(input_ids, **generate_args)

generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
print(generated_text)

The model produces the most probable response.

Prompt: Co to jest grawitacja? [EN: What is gravity?]

Answer: - To jest siła, która przyciąga przedmioty. [EN: - It is a force that attracts objects.]

To identify the best checkpoint in terms of response quality, I tested selected checkpoints on a set of 150 prompts with different structures: sentence completions, questions, and instructions:

• Sentence completions, e.g. "Warszawa jest stolicą..." ("Warsaw is the capital of...") and "Ziemia krąży wokół..." ("Earth orbits..."). The model generally recognized this as a structure that required completing a sentence. It also often provided a correct or the most "intuitive" completion. This category produced the fewest errors.
• Questions, ending with a question mark, e.g. "Co to jest planeta?" ("What is a planet?") and "Do czego służy ołówek?" ("What is a pencil used for?"). The model was expected to answer a question, just as a person would. It often recognized the question–answer pattern correctly. However, it also frequently struggled both with understanding the structure (that a question calls for an answer) and with factual knowledge about the world (it responded, but incorrectly).
• Instructions, e.g. "Wymień trzy warzywa" ("Name three vegetables") and "Podaj przykład pojazdu" ("Give an example of a vehicle"). An instruction is not a question, but it still requires an appropriate reaction — in this case, following the instruction or providing an answer. This type of prompt was the most difficult for the model, because it often failed to recognize that a response was required.

The full list of 150 prompts and Toktumi 1.0 responses (using 'greedy decoding') -> VIEW.

10. Ending the Training Run

After analyzing perplexity and the results of the 150-prompt tests, I selected checkpoint-1140000, saved after approximately 6,44 epochs, as the best checkpoint.

Further training was no longer producing enough improvement in response quality, so I decided to end the training run at this point.

The selected checkpoint contains the saved model weights. It forms the basis of the final Toktumi 1.0 model.

11. Final Model Evaluation

The final step was to evaluate the model and determine to what extent it met the objectives established at the beginning of the project — namely, whether it could hold conversations on a wide range of topics using everyday, conversational language.

Here, I will focus on the most important observations. The examples below were generated using greedy decoding.

a) Recognizing the Prompt

FINDINGS: The model often recognizes the structure of a prompt and generates a response that is grammatically and syntactically correct. It also uses an appropriate style. Interestingly, the model learned the Question–Answer structure mainly from the collection of jokes — many jokes take the form of a question followed by an answer (the punchline). This helped the model learn a simple rule: when a question is asked, it should be answered.

Prompt: Co to jest grawitacja? [EN: What is gravity?]

Answer: - To jest siła, która przyciąga przedmioty. [EN: - It is a force that attracts objects.]

Prompt: Co robi kucharz? [EN: What does a cook do?]

Answer: - Smaży kotlety. [EN: - Fries cutlets.]

Prompt: Warzywa są zdrowe, bo [EN: Vegetables are healthy because]

Answer: Warzywa są zdrowe, bo zawierają dużo witamin i minerałów. [EN: Vegetables are healthy because they contain plenty of vitamins and minerals.]

b) Basic Knowledge of the World

When a prompt is relatively simple, concerns commonly known facts, and does not require complex reasoning, the model often gives a correct answer. It therefore has general knowledge of the world and knows basic facts.

It performs best on prompts that require completing a sentence — this is the easiest format for the model to decode.

Prompt: Stolicą Francji jest [EN: The capital of France is]

Answer: - Stolicą Francji jest Paryż. [EN: - The capital of France is Paris.]

Prompt: Najwyższą górą na świecie jest [EN: The highest mountain in the world is]

Answer: Najwyższą górą na świecie jest Mount Everest, który ma wysokość 720 metrów. [EN: The highest mountain in the world is Mount Everest, which is 720 meters tall.]

(although the model gets the height wrong)

Prompt: Najdłuższą rzeką w Polsce jest [EN: The longest river in Poland is]

Answer: Najdłuższą rzeką w Polsce jest rzeka Wisła. [EN: The longest river in Poland is the Vistula River.]

c) Incorrect Answers

Sometimes the model generates a response that has the correct structure but is factually wrong — giving the impression that it is "making things up." This phenomenon is known as hallucination. It occurs when a model presents false or invented information as though it were factual.

As the tests show, hallucinations occur more frequently in less well-trained models, especially during the early stages of training. This is somewhat like a person who does not know the answer but tries to guess it anyway.

Prompt: Do czego służy ołówek? [EN: What is a pencil used for?]

Answer: - Do czyszczenia akwariów. [EN: - For cleaning aquariums.]

Prompt: Z czego robi się mąkę? [EN: What is flour made from?]

Answer: - Z proszku do pieczenia. [EN: - From baking powder.]

Prompt: Najszybszym zwierzęciem na lądzie jest [EN: The fastest land animal is]

Answer: Najszybszym zwierzęciem na lądzie jest koń. [EN: The fastest land animal is a horse.]

d) Lack of Understanding

Sometimes the model misinterprets the structure of a question or provides an internally contradictory answer.

Prompt: Księżyc świeci w [EN: The Moon shines at]

Answer: Księżyc świeci w nocy, a księżyc świeci nocą. [EN: The Moon shines at night, and the Moon shines during the night.]

Prompt: Co to jest ogień? [EN: What is fire?]

Answer: - To jest taki mały, biały, czerwony, świecący, czarny, żółty, zielony, niebieski, pomarańczowy, brązowy, fioletowy. [EN: - It's this little, white, red, glowing, black, yellow, green, blue, orange, brown, purple thing.]

Prompt: Jakie jedzenie przygotowujesz, kiedy masz gości? [EN: What food do you prepare when you have guests?]

Answer: - Na początku tygodnia. [EN: - At the beginning of the week.]

Additionally, when a prompt contains instructions, the model very often fails to recognize the expected type of response at all.

Prompt: Podziel się swoimi planami na weekend. [EN: Share your plans for the weekend.]

Answer: Horoskop dzienny - Lew. Dzisiejszy dzień przyniesie Ci wiele możliwości do rozwoju osobistego i zawodowego... [EN: Daily horoscope - Leo. Today will bring you many opportunities for personal and professional growth...]

(unexpectedly responds in the style of a horoscope)

Prompt: Wymień dwie przyprawy. [EN: Name two spices.]

Answer: Wymień dwie przyprawy. To proste! [EN: Name two spices. It's easy!]

(quotes a passage from an article on Pudelek or Fakt)

e) The 'Komentarz:' ('Comment:') Section

As I mentioned earlier, texts from the 'Wykop.pl' website were included in the Toktumi 1.0 training dataset together with user comments. This was the largest category of texts in the training dataset (1 413 999 samples).

The tests showed that internet comments significantly reduced the quality of the generated responses. They were rarely relevant to the topic and, despite moderation, still contained judgmental and offensive language, reinforced harmful stereotypes, and even included conspiracy theories.

Rather than simply misinterpreting the instruction, the model imitates the style of internet comments — often chaotic, judgmental, and inappropriate for the role of a friendly assistant.

Prompt: Jakie znasz środki transportu? [EN: What means of transportation do you know?]

Answer: (...)

Comment: Nie znam, ale się wypowiem. [EN: I don't know, but I'll give my opinion anyway.]

Prompt: Co sądzisz o podróżach po Europie? [EN: What do you think about traveling around Europe?]

Answer: (...)

Comment: Nie wiem, czy to dobry pomysł. W Polsce jest dużo taniej niż w Niemczech. [EN: I don't know if that's a good idea. It's much cheaper in Poland than in Germany.]

Prompt: Ziemia krąży wokół [EN: The Earth revolves around]

Answer: Ziemia krąży wokół Słońca. [EN: The Earth revolves around the Sun.]

Comment: To jest niesamowite, że w XXI wieku ludzie nadal wierzą w takie bzdury. (...) To tak jakby wierzyć, iż Ziemia krąży dookoła Słońca i jest okrągła. Albo, żeby wierzyć w płaską ziemię. No ale przecież ziemia jest płaska, więc ... [EN: It's incredible that in the 21st century people still believe such nonsense. (...) It's like believing that the Earth revolves around the Sun and is round. Or believing in a flat Earth. But of course the Earth is flat, so ...]

12. Recommendations and Next Steps

Based on these observations, I developed a short set of recommendations for further improving the model. I implemented the first two while developing the next version — Toktumi 2.0.

RECOMMENDATIONS:

1. Remove internet comments from the training dataset.
2. Conduct fine-tuning of the model (or train it again from scratch) on question–answer (QA) and instruction–answer (instruction fine-tuning) datasets.
3. Apply advanced text-cleaning techniques, with more effective filtering of undesirable and harmful content.
4. Consider using a GPT-2 model with more parameters: GPT-2 Large (762M) or GPT-2 XL (1.5B). GPT-2 Medium may have too little capacity and a limited attention mechanism to effectively retain knowledge and generate more complex responses. However, hardware constraints may be a barrier.
5. Use a newer model architecture that offers greater capabilities than GPT-2. However, hardware limitations and the high cost of training more advanced models may be obstacles.

Toktumi 1.0 on Hugging Face Spaces

You can try Toktumi 1.0 on Hugging Face Spaces:

https://huggingface.co/spaces/miczac/toktumi-1.0-polish-gpt2

NEXT PART

ROZDZIAŁ III. Toktumi 3.0. Trzeci trening.

1. Cel ponownego treningu

Toktumi 2.0 był znacznym postępem w stosunku do Toktumi 1.0, ale nadal miał problemy z poprawnością odpowiedzi, rozumieniem niektórych pojęć i zapętlaniem tekstu. (Szczegóły – zobacz Część 2).

Wcześniejsze eksperymenty pokazały, że uczenie na parach pytanie–odpowiedź (QA) oraz polecenie–odpowiedź (IA) przynosi dobre rezultaty. Postanowiłem więc rozwinąć to podejście, wykorzystując wcześniej zgromadzone teksty oraz API Google Gemini (Gemini 3.1 Flash-Lite) do syntetycznego generowania danych treningowych.

Chciałem sprawdzić, czy dalsze uczenie modelu wyłącznie na krótkich, uporządkowanych pytaniach, instrukcjach i dialogach pozwoli uzyskać lepsze rezultaty niż trening oparty głównie na surowych tekstach.

Podobnie jak poprzednie etapy, projekt ma charakter niekomercyjny i edukacyjno-badawczy.

2. Nowa koncepcja danych treningowych

W poprzednich wersjach Toktumi znaczną część korpusu stanowiły surowe teksty pozyskane z internetu: artykuły, książki, komentarze internetowe i inne materiały. W Toktumi 3.0 postanowiłem całkowicie zmienić to podejście.

Zamiast uczyć model bezpośrednio na surowych tekstach, cały korpus treningowy został przygotowany w formie krótkich, uporządkowanych rekordów, generowanych na podstawie materiałów źródłowych.

Przyjęto trzy podstawowe rodzaje rekordów:

• Pytanie → odpowiedź (QA) — rozwijanie wiedzy i rozumienia pojęć.
• Polecenie → odpowiedź (IA) — uczenie wykonywania instrukcji.
• Wypowiedź → reakcja (dialog) — rozwijanie umiejętności prowadzenia rozmowy.

Przykładowe kategorie rekordów:

Pytanie i odpowiedź:

Jaka jest stolica Francji?

Stolicą Francji jest Paryż.

<|endoftext|>

Polecenie i odpowiedź:

Wymień trzy planety Układu Słonecznego.

Merkury, Wenus i Ziemia.

<|endoftext|>

Dialog:

Chyba zapomniałem zabrać parasola.

Może sprawdź prognozę pogody, zanim wyjdziesz.

<|endoftext|>

Ważnym założeniem była samodzielność każdego rekordu. Pytanie lub polecenie musiało być zrozumiałe bez znajomości artykułu źródłowego czy pozostałych rekordów.

3. Wybór i pozyskanie materiałów źródłowych

Do przygotowania korpusu Toktumi 3.0 postanowiłem wybrać cztery główne źródła już zgromadzonych tekstów (zob. części o Toktumi 1.0 i Toktumi 2.0): Wielki słownik języka polskiego (WSJP), Wikipedię, Fakt oraz napisy filmowe i serialowe.

Każde źródło miało rozwijać inne umiejętności modelu:

• WSJP — język i znaczenia. Źródło danych zawierające definicje słów, związki frazeologiczne, typowe połączenia wyrazowe i przykłady użycia. Materiały miały poprawić rozumienie polskiego słownictwa i definiowanie pojęć.
• Wikipedia — wiedza. Artykuły encyklopedyczne dostarczające informacji o świecie i mające rozwijać umiejętność odpowiadania na pytania faktograficzne.
• Fakt.pl – wydarzenia. Artykuły prasowe dostarczające wiedzy o konkretnych wydarzeniach, ludziach i relacjach przyczynowo-skutkowych.
• Subtitles — rozmowa. Dialogi przygotowane na podstawie napisów do filmów miały nauczyć model prowadzenia naturalnej konwersacji oraz reagowania na emocje rozmówcy.

Wygenerowane próbki wg źródeł:

4. Generowanie danych treningowych

Do automatycznego tworzenia rekordów treningowych wykorzystałem przede wszystkim API Google Gemini. Od prac nad Toktumi 2.0 (2025) minął około rok. W tym czasie pojawiły się nowe, bardziej zaawansowane modele. Wcześniejszy Gemini 2.5 Flash (obecnie wycofywany) zastąpiłem modelem Gemini 3.1 Flash-Lite.

Dodatkowo korzystałem z uruchamianego lokalnie modelu Gemma 4 31B, który zastąpił wcześniejszy Mistral NeMo 12B. W moich testach Gemma lepiej radziła sobie z językiem polskim niż równie popularny obecnie (2026) Qwen3.6-35B-A3B.

Mechanizm działania: skrypt w Pythonie przesyła przez API do modelu Gemini 3.1 Flash-Lite kolejne teksty źródłowe wraz z odpowiednim promptem, określającym zasady generowania. Na podstawie każdego tekstu model tworzy 20 lub 30 rekordów treningowych w formie par Pytanie–Odpowiedź oraz Instrukcja–Odpowiedź. Gotowe rekordy są automatycznie zapisywane do plików txt.

Przy Toktumi 3 po raz pierwszy wykorzystałem napisy filmowe (subtitles) jako źródło danych treningowych. Duży zbiór napisów zgromadziłem już wcześniej ze źródeł internetowych, jednak początkowe próby pokazały, że surowe teksty dialogów nie nadają się do uczenia — model generuje chaotyczne ciągi wypowiedzi, nie rozpoznając rozmówców ani momentu, w którym należy zakończyć wypowiedź.

Rozwiązaniem okazało się dopiero przetworzenie napisów w krótkie, samodzielne pary dialogowe, w których jedna wypowiedź stanowi logiczną reakcję na drugą. W tej formie napisy mogły posłużyć do uczenia prowadzenia prostej rozmowy.

Przetwarzanie fragmentu napisów w zestaw par treningowych:

Kod i prompt do generowania danych działały na podobnej zasadzie jak w Toktumi 2.0 (zobacz Część 2).

Rekordy wygenerowane ze wszystkich czterech źródeł wymagały sprawdzenia pod kątem autonomiczności. Każde pytanie lub polecenie musiało być zrozumiałe samodzielnie, bez znajomości artykułu źródłowego czy wcześniejszego kontekstu.

Model automatycznie oceniał rekordy i oznaczał je jako 1 – zostaw lub 0 – odrzuć. W ten sposób eliminowałem pytania odwołujące się do nieznanych osób, wydarzeń czy wcześniejszych wypowiedzi.

Poniżej przykłady odrzuconych, nieautonomicznych rekordów wygenerowanych na podstawie artykułów newsowych.

PRĘDKOŚĆ PRZETWARZANIA DANYCH

Gemini przez API przetwarzał około 7–8 tekstów źródłowych na minutę (około 10 tys. na dobę), a lokalna Gemma 4 w wersji GGUF około 1–2 tekstów na minutę (około 2 tys. na dobę). Są to wartości szacunkowe.

Wygenerowanie i oczyszczenie wszystkich 6 190 420 par treningowych zajęło około 2,5 miesiąca.

5. Przygotowanie finalnego korpusu Toktumi 3.0

Podobnie jak w poprzednich wersjach Toktumi, połączyłem przygotowane dane w jeden duży korpus treningowy. Przedtem wymieszałem wszystkie 6 190 420 rekordów, aby podczas uczenia przeplatały się pytania, instrukcje i dialogi. Następnie podzieliłem zbiór na 99% danych treningowych (TRAIN) i 1% walidacyjnych (VALID), oddzielając rekordy tokenem <|endoftext|> - rozpoznawanym przez model jako znacznik końca tekstu.

Tu drobna uwaga: pomimo usunięcia duplikatów, ze względu na losowy podział danych nie można wykluczyć, że w zbiorach TRAIN i VALID znalazły się pytania podobne tematycznie.

Syntetycznie wygenerowane teksty okazały się znacznie krótsze niż te używane w poprzednich wersjach Toktumi, co widać na poniższej ilustracji. Średnio jeden rekord miał około 43 tokeny, a najdłuższy 174 tokeny. Długość sekwencji treningowej (block size) ustawiłem na 256 tokenów, dostosowując ją do takiej długości rekordów. Parametr ten ma również istotny wpływ na zużycie pamięci VRAM, więc w moim przypadku nie mógł być za wysoki.

Struktura zbioru uczącego z wymieszanymi tekstami:

Porównanie rozmiarów zbiorów treningowych Toktumi 1.0 | Toktumi 2.0 | Toktumi 3.0:

Porównanie z poprzednimi wersjami Toktumi pokazuje, jak bardzo zmienił się charakter zbioru treningowego. Toktumi 3.0 zawiera ponad 2,5 razy więcej rekordów niż Toktumi 2.0, a jednocześnie liczba słów i tokenów zmniejszyła się o około 53% w stosunku do Toktumi 2.0. Sam plik treningowy jest niemal o połowę mniejszy.

Model więc uczył się na większej liczbie przykładów, ale przy znacznie mniejszej liczbie tokenów. Tym razem postawiłem przede wszystkim na jakość, zwięzłość i uporządkowanie danych treningowych, zamiast zwiększania ich objętości.

Długość tekstów w zbiorach treningowych dobrze ilustruje poniższy wykres:

Boxplot pokazuje, jak bardzo skróciły się rekordy treningowe w kolejnych wersjach Toktumi.

Mediana długości: Toktumi 1.0 – 207 tokenów, Toktumi 2.0 – 145 tokenów, Toktumi 3.0 – zaledwie 41 tokenów.

Przy okazji na wykresie widać dwie najbardziej skrajne wartości odstające w Toktumi 1.0 i 2.0 (pojedyncze kropki z prawej strony) - czyli bardzo długie teksty, których nie wychwyciły stosowane przeze mnie na wcześniejszych etapach filtry długości. Mogą zawyżać średnią, dlatego jako miarę długości wybrałem medianę.

W Toktumi 3.0 rekordy powstawały od podstaw, dzięki czemu teksty mają bardziej ustandaryzowaną długość.

6. Trening Toktumi 3.0

Przed właściwym treningiem przeprowadziłem eksperyment na mniejszym zbiorze danych, aby sprawdzić, czy lepiej uczyć model od zera, czy kontynuować uczenie Toktumi 2.0. Testy wykazały przewagę fine-tuningu, dlatego zdecydowałem się wykorzystać wcześniej wyuczone umiejętności językowe modelu.

Zachowałem architekturę GPT-2 Medium oraz tokenizer Toktumi 2.0, aby zapewnić zgodność pomiędzy obu wersjami.

Trening zaplanowałem na maksymalnie 15 epok, z automatyczną walidacją, zapisywaniem checkpointów i mechanizmem early stopping, który miał zakończyć uczenie, gdy model przestanie się poprawiać.

Kluczowa część kodu użytego do uczenia modelu:

# Wczytanie Toktumi 2 i tokenizera
tokenizer = GPT2TokenizerFast.from_pretrained(TOKENIZER_PATH)
model = GPT2LMHeadModel.from_pretrained(MODEL_PATH)

# Przygotowanie danych
train_dataset = TokenBlockDataset(TRAIN_PATH, tokenizer, 256) # block_size = 256
valid_dataset = TokenBlockDataset(VALID_PATH, tokenizer, 256)

# Parametry treningu
training_args = TrainingArguments(
    output_dir=str(CHECKPOINT_DIR),
    num_train_epochs=15,
    per_device_train_batch_size=6,
    gradient_accumulation_steps=4,
    learning_rate=5e-5,
    fp16=True,
    eval_strategy="steps",
    eval_steps=8000,
    save_strategy="steps",
    save_steps=8000,
    save_total_limit=100,
    load_best_model_at_end=True,
    metric_for_best_model="eval_loss",
    greater_is_better=False,
)

# Fine-tuning z mechanizmem early stopping
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=valid_dataset,
    data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
    callbacks=[EarlyStoppingCallback(early_stopping_patience=6)],
)

trainer.train()
trainer.save_model(str(BEST_MODEL_DIR))

Zdecydowałem się zachować wszystkie checkpointy, co pomogło później porównać jakość odpowiedzi modelu na różnych etapach treningu.

Bogatszy o wcześniejsze doświadczenia, tym razem postanowiłem zastosować callback early stopping, zamiast ręcznie oceniać postępy na podstawie perplexity. Jak się okazało, była to dobra decyzja – nie musiałem już samodzielnie decydować, kiedy zakończyć trening. Z dużego zbioru danych wydzieliłem odpowiednio liczny zbiór walidacyjny, a mechanizm early stopping automatycznie zatrzymywał uczenie, gdy wartość eval_loss przestawała się poprawiać. Jeden cykl walidacji trwał około 3 minut, więc nie wydłużało to znacząco całego procesu.

TRENING W LICZBACH

Ze względu na wysokie ceny kart graficznych (2026) zdecydowałem się pozostać przy używanej do tej pory NVIDIA GeForce RTX 3060. Parametry treningu dopasowałem do dostępnej pamięci (12 GB VRAM).

• Jedna epoka: składała się z 44 538 kroków, a przejście przez 1 epokę zajmowało ok 16 godzin.
• Czas całego treningu: około 9,5 dnia, z przerwami i wznawianiem z checkpointów.
• Early stopping: automatycznie zakończył trening na 448 000. kroku, po 10,06 epoki.
• Najlepszy checkpoint według eval_loss: checkpoint-400000, osiągnięty pod koniec 9. epoki (8,98).
• Zapisane checkpointy: łącznie 56 (w dalszych testach wykorzystuję połowę z nich).

Wykres ilustrujący postęp treningu:

Po dziewiątej epoce train_loss nadal spadał, ale eval_loss przestał się poprawiać, co ostatecznie uruchomiło mechanizm early stopping.

Charakterystyczne „schodki” na wykresie train_loss (niebieska linia) pojawiają się regularnie na początku kolejnych epok. Nie muszą świadczyć o błędzie treningu, a jak można przypuszczać, mają związek z ponownym przemieszaniem danych treningowych i przebiegiem procesu optymalizacji.

7. Ocena jakości modelu — PROMPTING i testowanie checkpointów

W kolejnym kroku przetestowałem 29 wybranych checkpointów na dwóch dodatkowych zestawach testowych po 300 promptów, uzyskując łącznie 17 400 odpowiedzi — co stanowi obszerny materiał do analizy.

Z pomocą AI przeprowadziłem szacunkową ocenę FCT (Factuality), uwzględniając poprawność faktograficzną, sensowność i adekwatność odpowiedzi. Każda poprawna lub sensowna odpowiedź otrzymywała 1 punkt. Jest to umowne kryterium (szczegółowo opisałem je w Części 2), które pozwoliło porównać jakość odpowiedzi poszczególnych checkpointów.

Najlepsze wyniki (600 promptów):

• checkpoint-400000: 431/600 (71,8%)
• checkpoint-448000: 431/600 (71,8%)
• checkpoint-432000: 425/600 (70,8%)

Do dalszych testów wybrałem checkpoint-400000, który osiągnął również najniższy eval_loss podczas treningu i został automatycznie wskazany jako najlepszy przez mechanizm early stopping. Należy dodać, że różnice między najlepszymi checkpointami były niewielkie.

Wyniki checkpointów według kryterium Factuality (FCT) czyli poprawność, zgodność z faktami i sensowność odpowiedzi:

Ciekawostka: Na pytanie o pierwszego prezydenta USA (w trybie greedy decoding) checkpoint-384000 poprawnie wskazał George'a Washingtona, checkpoint-400000 błędnie podał George'a W. Busha, a checkpoint-448000 znów odpowiedział prawidłowo. Pokazuje to, że dłuższy trening nie zawsze gwarantuje poprawę odpowiedzi. Model potrafi udzielić prawidłowej odpowiedzi, ale nie zawsze wybiera ją jako najbardziej prawdopodobną.

Zestawy promptów wraz z odpowiedziami w podziale na checkpointy - do obejrzenia.

300 Pack 1 oraz drugi zestaw 300 Pack 2.

8. Porównanie wszystkich wersji modelu: Toktumi 1-2-3

W tym miejscu sprawdzam, jak Toktumi 3.0 wypada na tle poprzednich wersji (opisanych w Części 1 i Części 2). Wracam do zestawu 150 promptów, wykorzystanego wcześniej (weryfikacja Toktumi 1.0 i 2.0).

Test pokazuje, czy Toktumi 3.0 poprawnie rozpoznaje polecenie (IF), a następnie czy jego odpowiedź jest zgodna z faktami (gdy można zastosować kryterium prawdziwości) lub sensowna (bardziej subiektywna ocena w przypadku dialogów) (FCT). Wyniki klasyfikowałem jako TAK/TAK, TAK/HAL lub NIE, gdzie HAL oznacza halucyowanie, pomimo prawidłowego rozpoznania konstrukcji wypowiedzi (szczegóły – w części o Toktumi 2.0).

Wyniki Toktumi 1.0

Wyniki Toktumi 2.0

Wyniki Toktumi 3.0

Wyniki pokazują wyraźną poprawę jakości modelu. Odsetek poprawnych odpowiedzi wzrósł z 56,7% w Toktumi 1.0 do 76% w Toktumi 3.0, a liczba nierozpoznanych poleceń spadła z 32 do 5 na 150 promptów.

Toktumi 3.0 znacznie lepiej radzi sobie z poleceniami i częściej udziela poprawnych odpowiedzi, choć nadal popełnia błędy faktograficzne i generuje halucynacje.

Wyniki z odpowiedziami dla Toktumi 1-2-3 (150 promptów) TUTAJ

9. Testy jakościowe, czyli co potrafi model Toktumi 3.0?

W tym miejscu dokładnie sprawdzam możliwości i ograniczenia Toktumi 3.0.

Wykorzystałem dwa przygotowane wcześniej zestawy po 300 promptów (300 Pack 1 i 300 Pack 2). Wszystkie 600 odpowiedzi wygenerowałem w trybie greedy decoding.

Wyniki i wnioski poniżej.

a) FORMA: KRÓTSZE ODPOWIEDZI

Pierwsza zauważalna zmiana to sposób, w jaki model kończy wypowiedzi. W przeciwieństwie do wcześniejszych generacji, Toktumi 3.0 zazwyczaj udziela krótkiej odpowiedzi i nie kontynuuje niepotrzebnie tekstu. Zostały też znacznie ograniczone zapętlenia tekstu, charakterystyczne dla Toktumi 1 i 2.

Przykład zapętlenia tekstu - problem znacznie ograniczony w Toktumi 3. Ostatnia wersja modelu znacznie rzadziej wpada w powtórzenia i częściej udziela krótkich, poprawnych i spójnych odpowiedzi na zadany temat.

Krótkie odpowiedzi to znak rozpoznawczy Toktumi 3.0:

[Toktumi 3.0]

Prompt (v3, nr 7): W jakiej dyscyplinie sportu specjalizowała się Justyna Kowalczyk?

Odpowiedź: Biegi narciarskie.

Prompt (v3, nr 90): Jak nazywa się jednostka dziedziczenia znajdująca się w DNA?

Odpowiedź: Gen.

Prompt (v4, nr 43): Jak nazywa się naturalny satelita naszej planety?

Odpowiedź: Księżyc.

b) CO MODEL ROBI DOBRZE?

OK 1. Proste pytania i wykonywanie instrukcji

Model dobrze radzi sobie z poleceniami, które wymagają wskazania konkretnych przykładów, stworzenia krótkiej listy lub udzielenia jednoznacznej odpowiedzi.

[Toktumi 3.0]

Prompt (v4, nr 4): Wymień trzy rzeczy, które przydają się podczas pikniku.

Odpowiedź: Podczas pikniku przydają się: koc, napoje oraz przekąski.

Prompt (v4, nr 100): Wymień trzy polskie owoce sezonowe.

Odpowiedź: Truskawki, maliny, jagody.

Prompt (v4, nr 142): Wymień dwa sposoby podróżowania po mieście bez własnego samochodu.

Odpowiedź: Dwa sposoby to korzystanie z komunikacji miejskiej, takiej jak autobusy lub tramwaje, oraz chodzenie pieszo.

OK 2. Definicje i wyjaśnianie podstawowych pojęć

Toktumi 3 potrafi też formułować poprawne, rozbudowane wyjaśnienia:

[Toktumi 3.0]

Prompt (v4, nr 34): Wyjaśnij prostymi słowami, do czego służy termostat.

Odpowiedź: Termostat to urządzenie, które włącza lub wyłącza grzanie, gdy temperatura w pomieszczeniu spadnie poniżej ustawionego poziomu, co pozwala utrzymać w nim komfortową temperaturę.

Prompt (v3, nr 106): Opisz, czym jest szczepionka i jaki jest cel jej stosowania.

Odpowiedź: Szczepionka to preparat biologiczny, który uczy układ odpornościowy rozpoznawać i zwalczać konkretne drobnoustroje, takie jak wirusy czy bakterie, chroniąc przed zachorowaniem lub łagodząc przebieg choroby.

Prompt (v3, nr 125): Opisz, na czym polega funkcja Rzecznika Praw Obywatelskich w Polsce.

Odpowiedź: Rzecznik Praw Obywatelskich stoi na straży wolności i praw człowieka oraz obywatela, badając, czy organy władzy publicznej działają zgodnie z prawem i czy nie przekraczają swoich uprawnień.

W takich przykładach model generuje spójną wypowiedź, używając właściwego słownictwa i zachowując logiczną strukturę.

Wreszcie też prawidłowo podaje definicję ołówka, z czym poprzednie wersje Toktumi miewały problem.

OK 3. Rozumienie słów i frazeologizmów

Ciekawe są również odpowiedzi dotyczące znaczenia polskich słów i związków frazeologicznych, których model uczył się na podstawie słownika języka polskiego.

[Toktumi 3.0]

Prompt (v3, nr 22): Wyjaśnij słowo „zawzięty” w odniesieniu do osoby dążącej do celu.

Odpowiedź: Oznacza to, że osoba ta jest bardzo zdeterminowana, nie poddaje się łatwo i z wielkim zapałem realizuje swoje zamierzenia, nie zważając na przeszkody.

Prompt (v3, nr 292): Co znaczy frazeologizm „grać na zwłokę”, gdy ktoś unika podjęcia decyzji?

Odpowiedź: Oznacza to celowe opóźnianie jakiegoś działania lub decyzji, aby zyskać na czasie i uniknąć podjęcia właściwego wyboru.

Prompt (v4, nr 218): Jak rozumiesz „rzucać kłody pod nogi”?

Odpowiedź: To określenie sytuacji, w której ktoś celowo utrudnia innym osiągnięcie zamierzonego celu.

Co istotne, model potrafi nie tylko podać znaczenie, ale również wyjaśnić je innymi słowami niż w definicji.

OK 4. Krótkie, naturalne dialogi

W Toktumi 3.0 po raz pierwszy wykorzystałem napisy filmowe (subtitles), przetworzone w samodzielne pary dialogowe. Poniższe przykłady pokazują, że model teraz potrafi dopasować odpowiedź do sytuacji i ograniczyć się do jednej wypowiedzi - jak w prawdziwej rozmowie.

[Toktumi 3.0]

Prompt (v3, nr 230): Przepraszam za spóźnienie, autobus utknął w korku.

Odpowiedź: Nie szkodzi, najważniejsze, że już jesteś i możemy zaczynać.

Prompt (v3, nr 172): Obiecaj mi, że zachowasz to dla siebie.

Odpowiedź: Możesz być spokojny, nikomu nie pisnę ani słowa.

Prompt (v3, nr 238): Wreszcie dostałem tę pracę, o której ci opowiadałem!

Odpowiedź: To fantastyczna wiadomość, naprawdę się cieszę, że udało ci się ją dostać.

Prompt (v3, nr 219): Nie uwierzysz, co mi się dzisiaj przydarzyło!

Odpowiedź: Co takiego?

Niektóre reakcje są zaskakująco naturalne. Model potrafi rozpoznać emocjonalny ton rozmowy, wyrazić zainteresowanie lub odpowiedzieć potocznym językiem.

c) Z CZYM MODEL NADAL MA PROBLEMY?

Problem 1. Wiedza faktograficzna — poprawna forma, ale błędna treść

Największym problemem pozostają szczegółowe fakty: nazwiska, daty, wydarzenia historyczne i konkretne informacje o świecie.

[Toktumi 3.0]

Prompt (v3, nr 54): Kto był pierwszym prezydentem Stanów Zjednoczonych?

Odpowiedź: George W. Bush.

(Powinno być: George Washington.)

Prompt (v3, nr 16): Podaj imię i nazwisko pierwszej kobiety, która poleciała w kosmos.

Odpowiedź: Jurij Gagarin.

(Powinno być: Walentina Tierieszkowa.)

Prompt (v4, nr 1): Podaj nazwę norweskiej stolicy.

Odpowiedź: Stolicą Norwegii jest Bermudy.

(Powinno być: Oslo.)

Te przykłady dobrze pokazują, że model opanował formę odpowiadania znacznie lepiej niż wiedzę faktograficzną. Nie odmawia odpowiedzi i nie sygnalizuje niepewności — po prostu podaje nieprawdziwą informację (halucynuje).

Powyższe odpowiedzi uzyskano w trybie greedy decoding. Po wprowadzeniu losowania top_k=2 model potrafił również wskazać poprawne odpowiedzi: George’a Washingtona w 3 z 10 prób, a Oslo w 6 z 20 prób.

Wystarczy kilka prób i model w końcu prawidłowo podaje stolicę Norwegii.

Jednak losowanie nie zawsze pomaga. W przypadku pytania o pierwszą kobietę w kosmosie model ani razu na 100 prób nie wskazał Walentiny Tierieszkowej. Zamiast tego podawał m.in. Jurija Gagarina, Marię Skłodowską-Curie, projektantkę mody Jil Sander, aktorkę Gillian Anderson, a nawet Marię Czubaszek.

Przeszukałem zbiór uczący - okazuje się, że ta informacja pojawiła się w datasecie kilkukrotnie.

Postanowiłem więc przeformułować pytanie na „Kim była Walentina Tierieszkowa?”. Tym razem model odpowiada poprawnie:

„Była radziecką kosmonautką, która jako pierwsza kobieta w historii poleciała w kosmos."

Jak widać, model zna tę informację, ale ma problem z powiązaniem jej z właściwą osobą.

Problem 2. Model potrafi 'zepsuć' poprawną odpowiedź, dopisując błędne wyjaśnienie

To szczególnie interesujący rodzaj halucynacji.

Prompt (v3, nr 1): Wskaż, nad jaką rzeką położony jest Sandomierz.

Odpowiedź: Sandomierz leży nad rzeką Wisłą, która jest dopływem Wisły.

Pierwsza część odpowiedzi jest poprawna. Druga — bez sensu.

Inny przykład - pytanie o fotosyntezę:

Prompt (v3, nr 43): Jaki gaz rośliny pobierają z atmosfery w procesie fotosyntezy?

Odpowiedź: W procesie fotosyntezy z atmosfery pobierają dwutlenek węgla, który jest niezbędny do oddychania dla większości roślin.

Model prawidłowo wskazuje dwutlenek węgla, ale błędnie wyjaśnia jego funkcję.

Problem 3. Rozumienie znaczenia nie zawsze idzie w parze ze znajomością języka

Mimo wielu udanych definicji model ma problemy z niektórymi, nawet popularnymi wyrażeniami.

[Toktumi 3.0]

Prompt (v4, nr 134): Co oznacza „mieć dwie lewe ręce”?

Odpowiedź: Oznacza to, że osoba wykonująca pracę ma dwie ręce jednocześnie, co często zdarza się w zawodach wymagających precyzji lub w sytuacjach wymagających dużej siły fizycznej.

Prompt (v4, nr 296): Wyjaśnij pojęcie „syzyfowa praca”.

Odpowiedź: Jest to określenie sytuacji, w której ktoś wykonuje swoje zadania w sposób bardzo powolny, bez wkładania w nie żadnego wysiłku, co prowadzi do szybkiego zakończenia pracy.

W pierwszym przypadku model interpretuje frazeologizm niemal dosłownie. W drugim tworzy płynne wyjaśnienie, które jednak jest halucynacją i nie oddaje właściwego znaczenia słownikowego.

Po sprawdzeniu zbioru treningowego okazało się, że zwrot „mieć dwie lewe ręce” występował w zbiorze uczącym 40 razy, a „syzyfowa praca” 58 razy - wśród nich były zarówno definicje, jak i użycia w dialogach w różnych kontekstach. W tym przypadku również wystarczyło przeformułować prompt - i od razu pojawiły się prawidłowe odpowiedzi:

[Toktumi 3.0]

Prompt: Co potocznie oznacza zwrot mieć dwie lewe ręce?

Odpowiedź: Oznacza to, że ktoś jest niezdarny, mało sprawny fizycznie lub nie radzi sobie z wykonywaniem prostych czynności manualnych.

Prompt: Co to jest syzyfowa praca?

Odpowiedź: Syzyfowa praca to określenie na bardzo ciężką, żmudną i wymagającą wysiłku pracę, która nie przynosi żadnych widocznych efektów.

Wniosek jest podobny jak w przypadku Tierieszkowej: model przyswoił wiedzę, ale nie zawsze potrafi wskazać prawidłową odpowiedź jako najbardziej oczywistą. Czasem wystarczy odpowiednio przeformułować prompt lub zadać pytanie inaczej, aby osiągnąć zamierzony efekt.

Problem 4. Codzienne sytuacje i wiedza zdroworozsądkowa

Prompt (v4, nr 201): Co zrobić, gdy na kuchennej podłodze leżą odłamki rozbitej szklanki?

Odpowiedź: Należy niezwłocznie wezwać pogotowie ratunkowe, dzwoniąc pod numer alarmowy 112, a następnie zabezpieczyć miejsce zdarzenia i nie próbować samodzielnie naprawiać rozbitych szklanek czy talerzy.

Model rozpoznaje, że chodzi o bezpieczeństwo, ale proponuje działanie zupełnie nieproporcjonalne do sytuacji.

Jeszcze jeden przykład:

Prompt (v4, nr 263): Kupiłem aparat fotograficzny. Od czego zacząć naukę robienia zdjęć?

Odpowiedź: Najpierw naucz się obsługi miksera, potem spróbuj zrobić kilka zdjęć w różnych warunkach oświetleniowych, a na koniec spróbuj zrobić kilka ujęć w różnych miejscach, aby sprawdzić, jak najlepiej ustawić aparat.

Odpowiedź zaczyna się od przypadkowego zalecenia dotyczącego miksera, po czym wraca do właściwego tematu fotografowania, choć robi to w sposób dość chaotyczny.

Warto jednak zauważyć, że Toktumi 3 potrafi również udzielać rozsądnych porad dotyczących codziennych sytuacji. Przykładowo:

Prompt (v4, nr 93): Dlaczego nie wolno dotykać przewodów wystających z uszkodzonego gniazdka?

Odpowiedź: Dotykanie przewodów elektrycznych może doprowadzić do zwarcia, awarii instalacji lub porażenia prądem, dlatego należy zachować ostrożność.

Przykłady pokazują, że wiedza zdroworozsądkowa nadal sprawia modelowi trudności. Toktumi 3.0 potrafi czasem udzielić trafnej, praktycznej porady, ale zdarza mu się również proponować działania nieproporcjonalne do sytuacji lub łączyć informacje, które do siebie nie pasują.

Problem 5. Naturalna rozmowa to nie zawsze zrozumienie intencji

Choć model dobrze radzi sobie z krótkimi reakcjami dialogowymi, gorzej wypada, gdy rozmówca oczekuje określonego działania.

Prompt (v4, nr 275): Sąsiad zaprosił nas na grill, ale nie możemy przyjść. Jak grzecznie odmówić?

Odpowiedź: - Jasne, nie ma problemu.

Zamiast zaproponować uprzejmą odmowę, model generuje krótką odpowiedź dialogową, która nie realizuje polecenia.

Podobnie w sytuacji wymagającej porady:

Prompt (v4, nr 83): Muszę jutro wcześnie wstać. Jak się przygotować, żeby nie zaspać?

Odpowiedź: Zacznij od szklanki wody, to zawsze pomaga na żołądek.

Model odpowiada płynnie, ale nie udziela porady, jakiej zapewne oczekiwał rozmówca.

Problem może wynikać ze sposobu przygotowania krótkich, autonomicznych par dialogowych, które nie uwzględniają szerszego kontekstu rozmowy. Model nauczył się naturalnie reagować na pojedyncze wypowiedzi, ale nie zawsze prawidłowo rozpoznaje intencje i role rozmówców.

Rozwiązaniem mogłoby być uczenie modelu na dłuższych, wieloetapowych dialogach, zachowujących kontekst i role rozmówców. Wymagałoby to jednak bardziej złożonego przygotowania danych.

d) DODATKOWE CIEKAWOSTKI

Ciekawostka 1. Skąd się biorą dzieci? — pytanie, które wprawia w zakłopotanie

Postanowiłem sprawdzić, jak Toktumi 3 radzi sobie z pozornie banalnym pytaniem: „Skąd się biorą dzieci?”. Przetestowałem 29 checkpointów (połowę zapisanych), aby zobaczyć, jak odpowiedzi zmieniały się w trakcie treningu. Wynik był zaskakujący — żaden z checkpointów nie udzielił poprawnej odpowiedzi. Zamiast wyjaśniać biologię, model zachowywał się niemal jak zakłopotany dorosły, próbujący uniknąć niewygodnego tematu:

[Toktumi 3.0]

Checkpoint-48000: To nie jest pytanie, na które chciałbyś usłyszeć odpowiedź.

Checkpoint-80000: To nie jest temat do rozmowy przy śniadaniu.

Checkpoint-272000: To pytanie, na które nie dostaniesz odpowiedzi.

Checkpoint-400000: Nie mam pojęcia, ale na pewno nie są to dzieci, o których teraz wspominasz.

Co ciekawe, wystarczyło zapytać inaczej. Na pytanie „Jak powstają dzieci?” odpowiadał już prawidłowo:

Powstają one w wyniku zapłodnienia komórki jajowej przez plemnik, co prowadzi do powstania zygoty.

Odpowiedź jest bardziej charakterystyczna dla języka biologii i medycyny niż codziennej rozmowy, jednak należy ją uznać za poprawną.

To ciekawy przykład odwzorowania językowego obrazu świata — model naśladuje nie tylko naszą wiedzę, ale również sposób myślenia i skojarzenia utrwalone w języku.

Ciekawostka 2. Czy Bóg istnieje? - metafizyczne rozterki sztucznej inteligencji

Kolejnym eksperymentem było pytanie „Czy Bóg istnieje?”, które zadałem wszystkim 29 checkpointom, aby sprawdzić, jak odpowiedzi zmieniały się wraz z postępem uczenia. Wyniki były zaskakujące — Toktumi wielokrotnie zmienia odpowiedź z „tak” na „nie” i odwrotnie.

W miarę postępu treningu można zauważyć pewną prawidłowość: początkowo przeważało „nie”, w środkowej fazie zdecydowanie „tak”, a pod koniec ponownie „nie”. Można więc powiedzieć półżartem, że Toktumi wraz z postępem uczenia najpierw „nabywał wiarę”, a następnie ją „tracił”!

Ciekawostka 3. Sztuczna inteligencja uczy się przeklinać

W słowniku języka polskiego znajdziemy również wyrazy wulgarne i pejoratywne — to naturalna część polszczyzny. Obok mocnych wulgaryzmów występują tam określenia takie jak „patafian”, „łajza”, „zadupie”, a także zwroty „zakuty łeb” czy „dupa wołowa”.

Podczas przetwarzania takich haseł Gemini często blokował generowanie odpowiedzi ze względu na mechanizmy moderacji. Dlatego wykorzystałem mniej restrykcyjny lokalny model Gemma, aby również z tego materiału przygotować pary pytań i instrukcji.

Sprawdzamy, czy Toktumi potrafi przeklinać. Jak się okazuje, model przyswoił sobie zasób wulgarnego słownictwa, ale czasem miesza dosadne przekleństwa z zupełnie łagodnymi powiedzeniami:

Prompt: Wymień znane ci przekleństwa.

Odpowiedź: Do popularnych przekleństw należą: „kurwa mać”, „spadaj” oraz „srali muchy będzie wiosna”.

innym razem wpada w ciąg powtórzeń:

Prompt: Jakie są najgorsze przekleństwa w języku polskim?

Odpowiedź: Najgorszymi przekleństwami są wyrazy takie jak kurczę, ojejku, ojejku, ojejku czy też słowa typu kurczę pieczone.

a niekiedy wręcz odmawia wykonania polecenia:

Prompt: Wyraź swoją złość, używając mocnego przekleństwa.

Odpowiedź: Nie będę się zniżał do twojego poziomu, bo to nie jest miejsce na takie rozmowy.

PODSUMOWANIE I WNIOSKI KOŃCOWE

Projekt Toktumi pokazał, jak wiele można osiągnąć, rozwijając stosunkowo niewielki model językowy GPT-2 Medium. Trzy kolejne generacje powstały na bazie tej samej architektury, ale różniły się sposobem przygotowania danych i przebiegiem uczenia. Najważniejsze zmiany zaszły nie w wielkości modelu, lecz w tym, czego i jak go uczono.

Trzy generacje — trzy etapy rozwoju

• Toktumi 1.0 — model nauczył się pisać po polsku. Potrafił tworzyć płynne wypowiedzi, ale często zamiast odpowiadać na pytania, kontynuował artykuły lub generował komentarze niezwiązane z poleceniem. Samo opanowanie języka nie wystarczyło do prowadzenia sensownej rozmowy.
• Toktumi 2.0 — model nauczył się odpowiadać. Przebudowa zbioru treningowego i wprowadzenie pytań oraz instrukcji przyniosły największy przełom w rozpoznawaniu poleceń. Liczba przypadków ich nierozpoznania spadła z 32 do 6 na 150 promptów. Model znacznie częściej wiedział już, jakiego rodzaju odpowiedzi od niego oczekujemy.
• Toktumi 3.0 — model opanował umiejętność prostej rozmowy. Uczenie na starannie przetworzonych i uporządkowanych danych treningowych, w tym parach dialogowych, pozwoliło mu odpowiednio reagować na wypowiedzi rozmówcy, uwzględniając ich kontekst i emocjonalny charakter. W teście porównawczym osiągnął 114 poprawnych odpowiedzi na 150, czyli najwięcej ze wszystkich modeli.

Najciekawsze wnioski z dotychczasowych eksperymentów

• Model uczy się przede wszystkim tego, co znajduje się w danych treningowych. Jeśli nie ma w nich przykładów opowiadania dowcipów, programowania czy rozwiązywania zadań, model nie nauczy się tych umiejętności. LLM potrafi łączyć informacje, uogólniać je i tworzyć nowe treści, ale jego możliwości wynikają przede wszystkim z tego, co znajduje się w danych treningowych.
• Model może znać poprawną odpowiedź, ale nie zawsze wybiera ją jako najbardziej prawdopodobną. Analiza checkpointów pokazała, że model potrafi odpowiadać poprawnie, po dalszym treningu błędnie, a następnie znów poprawnie. Nie musi to oznaczać utraty wcześniej zdobytej wiedzy — podczas uczenia zmieniają się tylko prawdopodobieństwa generowanych odpowiedzi.
• Jakość i struktura danych treningowych mogą być ważniejsze niż ich ilość. Toktumi 1.0 uczył się na milionach surowych tekstów, ale dopiero wprowadzenie uporządkowanych pytań, instrukcji i dialogów przyniosło wyraźną poprawę. Eksperymenty pokazały, jak duże znaczenie ma odpowiedni dobór i przetworzenie materiałów źródłowych.
• Czasem tajemnica tkwi w odpowiednim sformułowaniu promptu. Model może posiadać określoną wiedzę, ale nie potrafić jej przywołać przy konkretnym pytaniu. Niekiedy wystarczy inaczej sformułować prompt, dodać kontekst lub odpowiednio naprowadzić model, aby uzyskać poprawną odpowiedź.
• Model uczy się nie tylko informacji i słów, ale również ludzkich sposobów postrzegania świata. W języku zakodowane są nasze opinie, przekonania i stereotypy, które model może nauczyć się odtwarzać. Potrafi robić to tak naturalnie i przekonująco, że łatwo odnieść wrażenie, jakby wyrażał własne, rzeczywiste poglądy.

Wniosek końcowy

Realizacja projektu wymagała połączenia wiedzy z wielu dziedzin — programowania, przetwarzania danych, językoznawstwa, uczenia maszynowego oraz konfiguracji i optymalizacji sprzętu. W praktyce oznaczało to mierzenie się zarówno z problemami technicznymi, jak i z pytaniami o to, jak model przyswaja język, zdobywa wiedzę i uczy się odpowiadać.

Mimo ograniczeń sprzętowych i możliwości architektury GPT-2 Medium udało się zrealizować najważniejsze założenia projektu. Eksperyment pokazał, że nawet jedna osoba, dysponując domowym sprzętem, może stworzyć i wytrenować działający model językowy.

Model Toktumi 3.0 w Hugging Face Spaces

Model Toktumi 3.0 można przetestować na platformie Hugging Face Spaces:

https://huggingface.co/spaces/miczac/toktumi-3.0-polish-gpt2

ROZDZIAŁ II. Toktumi 2.0. Drugi trening.

W tej części opisuję drugi etap projektu Toktumi, który ma charakter edukacyjno-badawczy i niekomercyjny. Wprowadzam w nim poprawki wynikające z doświadczeń i wniosków z treningu Toktumi 1.0.

Dla przypomnienia: W poprzednim etapie stworzyłem i wytrenowałem od podstaw polskojęzyczny model GPT-2 Medium, wykorzystując 3 115 002 próbki własnoręcznie zebranych i oczyszczonych tekstów. Przygotowałem własny tokenizer, przeprowadziłem trening i testy jakości odpowiedzi. W efekcie Toktumi 1.0 nauczył się generować poprawne językowo teksty, jednak często miał problemy z rozpoznawaniem poleceń i udzielaniem poprawnych odpowiedzi.

Po więcej szczegółów odsyłam do Części 1.

1. Cel ponownego treningu

Postanowiłem ponownie wytrenować model od podstaw. Celem było wdrożenie dwóch kluczowych rekomendacji:

1. Usunięcie komentarzy internetowych ze zbioru treningowego, co - jak przypuszczałem - pozwoli wyeliminować treści chaotyczne i niskiej jakości.
2. Dodanie zestawów typu Pytanie-Odpowiedź (QA) oraz Instrukcja-Odpowiedź (IA), aby model lepiej uczył się interakcji z użytkownikiem i generował spójne odpowiedzi na konkretne prompty i polecenia.

Fine tuning czy ponowne uczenie?

Zamiast fine-tuningu (dalszego uczenia już wytrenowanego modelu), zdecydowałem się na pełne ponowne uczenie. Wynikało to z obawy, że fine-tuning nie wyeliminuje problemów obecnych w pierwotnym zbiorze danych. Trening od zera pozwala zbudować model w oparciu wyłącznie o oczyszczony i właściwie przygotowany korpus tekstów, co zwiększa kontrolę nad jakością uzyskanego rezultatu.

Ponieważ proces trenowania modelu został już wcześniej przeprowadzony w całości, druga iteracja okazała się prostsza i mniej czasochłonna. Wiele elementów można było powtórzyć bez większych modyfikacji, a konieczne poprawki wprowadzić tylko tam, gdzie to konieczne. Tak jak za pierwszym razem, największym wyzwaniem okazało się przygotowanie nowych tekstów do uczenia modelu, tym razem w formie par pytań i instrukcji z odpowiedziami.

2. Zaplanowanie kolejnych etapów

2a. Zebranie nowych danych - przygotowanie zestawów typu Pytanie-Odpowiedź (QA) oraz Instrukcja-Odpowiedź (IA).

2b. Stworzenie pełnego zbioru treningowego.

2c. Trening od podstaw - przeprowadzenie pełnego uczenia w architekturze GPT-2 Medium, wykorzystując poprawiony zbiór tekstów.

2d. Ocena jakości modelu - etap 1 - pomiar perplexity checkpointów.

2e. Ocena jakości modelu - etap 2 - prompting, weryfikacja ludzka.

2f. Zakończenie treningu na wybranym checkpoincie.

2a. Zebranie danych. Zestawy Pytanie-Odpowiedź (QA), Instrukcja-Odpowiedź (IA)

Tę część rozpocząłem na początku 2025 roku. Nie znalazłem wówczas w sieci rozbudowanych zestawów instrukcji w języku polskim – choć były dostępne w innych językach - głównie po angielsku, np. databricks-dolly-15k (15 tys. przykładów, angielski), HuggingFaceH4 helpful-instructions (150 tys. przykładów, angielski), OIG: Open Instruction Generalist (44 mln przykładów, angielski), Aya Dataset (513 mln przykładów w ponad 100 językach, ale w języku polskim jest ich stosunkowo niewiele).

W tym wypadku kuszącym rozwiązaniem wydawało się wygenerowanie takich danych samodzielnie, przy pomocy istniejących modeli LLM. Tego typu podejście bywa określane jako generowanie danych syntetycznych (synthetic data). Więcej na ten temat [Artykuł].

Zdecydowałem się przeprowadzić dwa eksperymenty:

• Generowanie lokalnie na domowym PC z użyciem modelu Mistral-Nemo-12B-Instruct-2407 pobranego z serwisu Hugging Face - obsługę promptów kontrolowałem z poziomu Pythona.
• Generowanie z użyciem Gemini API (model Google), co pozwoliło mi nie tylko zebrać dane, ale także poćwiczyć integrację Pythona z zewnętrznym API i porównać jakość wyników. Użyłem modelu gemini-2.5-flash.

Oba podejścia miały swoje zalety i ograniczenia. Model Mistral, uruchamiany lokalnie, zapewniał pełną kontrolę nad procesem i uniezależniał od usług zewnętrznych. Wadą były jednak ograniczenia sprzętowe (GeForce RTX 3060), co wiązało się z długim czasem generowania oraz znacznym zużyciem energii - większym niż w przypadku samego trenowania modelu.

Z kolei model Gemini, dostępny w chmurze, jest szybszy, prostszy w obsłudze i generuje bardziej dopracowane językowo odpowiedzi. Wadą tego rozwiązania są jednak ograniczenia i limity narzucone przez API, które utrudniały generowanie tekstów na dużą skalę. Alternatywą było korzystanie z płatnego dostępu, jednak przy tak dużej liczbie tekstów koszty byłyby zbyt wysokie w stosunku do ograniczonego budżetu projektu.

ZESTAWY INSTRUKCJI GENEROWANE LOKALNIE (MISTRAL NEMO 12B)

Do generowania zestawów typu Pytanie-Odpowiedź (QA) oraz Instrukcja-Odpowiedź (IA) wykorzystałem model Mistral-Nemo-12B-Instruct-2407, uruchamiany lokalnie na domowym PC.

Sposób działania kodu: W katalogu roboczym znajdowały się pliki tekstowe (.txt) z artykułami o różnorodnej tematyce, pozyskane wcześniej z serwisów fakt.pl oraz polsatnews.pl. Każdy z tekstów przekazywałem do modelu wraz z rozbudowanym promptem, który precyzyjnie określał oczekiwany format wyjściowy (pytania i instrukcje wraz z odpowiedziami). Było to zarazem ciekawe ćwiczenie z zakresu prompt engineeringu. W przypadku modelu Mistral 12B kluczowe znaczenie miało dopracowanie treści promptu - dopiero rozbudowane testy przyniosły zadowalający efekt.

Wraz z promptem model dostaje następujące zadanie:

• wygeneruj maksymalnie pięć pytań różniących się strukturą i długością, wraz z odpowiedziami,
• ogranicz pytania zamknięte typu „tak/nie” (model miał skłonność do nadużywania tego formatu),
• wygeneruj różne warianty instrukcji na temat danego artykułu,
• posługuj się wyłącznie poprawną, płynną polszczyzną,
• unikaj dodatkowych komentarzy i oznaczeń (np. gwiazdek czy myślników), które Mistral jednak okazjonalnie wciąż wprowadzał.

Tak przygotowany proces pozwalał automatycznie tworzyć gotowe zestawy par tekstowych. Poniżej fragment kodu użytego do przetworzenia przykładowego artykułu.

Przykład: Oryginalny tekst przetwarzany na zestaw pytań i instrukcji.

Kod do generowania zestawów wczytuje artykuł, przekazuje go do modelu wraz z przygotowanym promptem, a następnie generuje odpowiedzi. Ze względu na ograniczenia sprzętowe, wykorzystałem też kwantyzację 4-bitową. Więcej o kwantyzacji.

import random
import torch
from time import time
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig

# Model i plik źródłowy
model_id = "Mistral-Nemo-12B-Instruct-2407"
input_file = "sample.txt"

# Kwantyzacja 4-bitowa
quant_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4"
)

# Wczytanie modelu i tokenizera
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto",
    quantization_config=quant_config
).eval()

# Wczytanie artykułu
with open(input_file, "r", encoding="utf-8") as f:
    text = f.read().strip()

# Losowanie czasowników do przykładów instrukcji
verbs = [
    "Opisz", "Streść", "Wyjaśnij", "Wymień", "Znajdź",
    "Podaj", "Napisz", "Wylicz", "Przeanalizuj",
    "Określ", "Uzasadnij", "Przedstaw", "Oceń",
    "Scharakteryzuj", "Wskaż", "Zdefiniuj", "Porównaj",
    "Zaproponuj", "Uporządkuj", "Powiedz", "Opowiedz"
]

random.shuffle(verbs)
examples = ", ".join(verbs[:7])

# Prompt — pełna treść przedstawiona poniżej
prompt_template = """treść promptu"""
prompt = prompt_template.format(examples=examples, text=text)

# Przygotowanie wejścia dla modelu
messages = [
    {"role": "system", "content": ""},
    {"role": "user", "content": prompt.strip()}
]

chat_input = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    return_tensors="pt"
).to(model.device)

# Generowanie pytań, instrukcji i odpowiedzi
start_time = time()

with torch.inference_mode():
    outputs = model.generate(
        chat_input,
        max_new_tokens=1024,
        do_sample=True,
        temperature=0.4,
        top_p=0.7
    )

# Dekodowanie samej wygenerowanej odpowiedzi
generated_ids = outputs[0][chat_input.shape[-1]:]
result = tokenizer.decode(generated_ids, skip_special_tokens=True).strip()

print(result)
print(f"Czas generowania: {time() - start_time:.2f} s")

Kluczowym elementem jest treść promptu (sformułowanego po polsku, który Mistral obsługuje):

Zadaj maksymalnie 5 pytań, na które odpowiedzi znajdują się w treści. Pytania muszą być różnorodne pod względem struktury i długości. Nie wolno zadawać więcej niż jednego pytania, które zaczyna się od „Czy”. Nie zadawaj więcej niż jednego pytania, którego odpowiedź mogłaby być „tak” lub „nie”. Zabronione jest powtarzanie pytań. Pod pytaniem zawsze napisz odpowiedź. Odpowiedź ma być tak szczegółowa, jak to potrzebne.

Następnie stwórz kilka przykładowych tekstów instrukcji w kontekście treści tego tekstu (format imperativus, np. {examples}). To tylko przykłady, wybierz takie, które najbardziej będą pasować do tekstu. Staraj się, aby teksty instrukcji były różnorodne i różniły się między sobą. Zabronione jest powtarzanie instrukcji. Pod instrukcją zawsze napisz odpowiedź. Odpowiedzi powinny być różnorodne.

Uwagi do całego tekstu, który stworzysz: Pisz tylko i wyłącznie w języku polskim. Pisz płynną, poprawną polszczyzną. Nie oznaczaj tekstu dodatkowymi komentarzami od siebie. Nigdy nie stosuj gwiazdek '*', '**' ani myślników '-' w celu wyróżnienia tekstu. Chcę mieć czysty tekst gotowy do użycia: pytanie-odpowiedź, instrukcja-odpowiedź. Nie dodawaj nic więcej. Zapisz wszystko jako ciąg pytań i odpowiedzi oddzielonych pustymi liniami.

Tekst: {text}

Prompt musiał obejmować takie szczegóły, ponieważ jak pokazały testy, model szedł po linii najmniejszego oporu i miał tendencję do tworzenia powtarzalnych konstrukcji, często zaczynających się od „Czy”. Dlatego w prompcie wprowadziłem ograniczenie liczby takich sformułowań.

Poza tym, przy tworzeniu instrukcji zastosowałem prostą sztuczkę z wykorzystaniem zmiennej {examples}. Model miał tendencję do generowania monotonnych, powtarzających się poleceń. Wytypowałem więc 21 czasowników, które najlepiej sprawdzały się w tym zadaniu. Następnie dla każdego artykułu losowałem 7 z nich i podsuwałem modelowi jako przykłady w prompcie. Testy pokazały, że był to najskuteczniejszy sposób na zwiększenie różnorodności generowanych instrukcji, zarówno w przypadku lokalnego Mistrala, jak i Gemini API.

MISTRAL - UZYSKANE WYNIKI:

Kod poprawnie przekształcał tekst źródłowy w zestaw pytań i instrukcji wraz z odpowiedziami. Proces generowania był jednak stosunkowo czasochłonny — na mojej karcie graficznej zajmował średnio około 1 min na artykuł.

Przy zastosowaniu kwantyzacji 4-bitowej w generowanych tekstach pojawiały się drobne niedoróbki językowe, np. „Kto był Adam West?” zamiast „Kim był Adam West?”. W przypadku lokalnego modelu Mistral tego rodzaju konstrukcje występowały stosunkowo często, co wpływało na jakość zbioru treningowego. Pomimo tego, metoda dobrze spełniała swoje zadanie.

Test z Mistralem był wartościowym eksperymentem, ukazującym zarówno potencjał, jak i ograniczenia pracy z dużymi modelami uruchamianymi lokalnie.

ZESTAWY INSTRUKCJI GENEROWANE ONLINE, ZA POMOCĄ GEMINI API (GOOGLE)

W ramach drugiego eksperymentu wykorzystałem popularny w tamtym okresie (2025) model Gemini 2.5 Flash opracowany przez Google, dostępny przez API. Takie rozwiązanie pozwala na integrację modelu z Pythonem i automatyzację generowania tekstów, w tym seryjne przetwarzanie wielu plików.

Podobnie jak w przypadku Mistrala, przetwarzałem artykuły źródłowe na zestawy pytań i instrukcji wraz z odpowiedziami. Różnica polega na tym, że całe obciążenie obliczeniowe jest po stronie dostawcy usługi.

Gemini 2.5 Flash okazał się znacznie skuteczniejszy od lokalnego Mistrala 12B. Generował teksty napisane płynniejszą polszczyzną, lepiej interpretował polecenia i bardziej rygotystycznie przestrzegał wymaganego formatu odpowiedzi.

GEMINI - UZYSKANE WYNIKI:

Gemini 2.5 Flash generowało treści ponad dwukrotnie szybciej (ok. 30 sekund na artykuł) oraz w wyższej jakości. Model również sprawniej radził sobie z bardziej złożonymi poleceniami, takimi jak wstawianie separatorów.

Korzystanie z API ma jednak swoje ograniczenia, przede wszystkim limity liczby zapytań i generowanych tokenów. Przy przetwarzaniu dużej liczby artykułów stanowiło to spore utrudnienie, którego nie było w przypadku modelu uruchamianego lokalnie.

Ostatecznie, większość tekstów wygenerowałem lokalnie przy użyciu modelu Mistral.

Przykład: Fragment zbioru uczącego. Wyczyszczone, gotowe do uczenia zestawy Pytanie-Odpowiedź (QA) oraz Instrukcja-Odpowiedź (IA).

Po ponad 40 dniach generowania danych w obu środowiskach (lokalnym i chmurowym) udało mi się zebrać 616 279 par tekstów w formacie Pytanie-Odpowiedź (340 447) oraz Instrukcja-Odpowiedź (275 832).

Generowanie danych syntetycznych na dużą skalę jest kosztowne i czasochłonne — wymaga dużej mocy obliczeniowej, zarówno przy korzystaniu z lokalnego GPU, jak i usług API.

Web scraping jest znacznie szybszy i tańszy, ale nie zawsze pozwala uzyskać teksty o odpowiedniej jakości i strukturze.

Alternatywą mogłoby być automatyczne tłumaczenie gotowych zestawów instrukcji z języka angielskiego. Nie zdecydowałem się jednak na to rozwiązanie, ponieważ wyniki dotychczasowych eksperymentów uznałem za wystarczające.

2b. Przygotowanie nowego zbioru treningowego

W nowym zbiorze treningowym wykorzystałem zebrane wcześniej teksty ze źródeł: Wikipedia, Pudelek, Polsat News, książki oraz Fakt. Zrezygnowałem natomiast z tekstów Wykopu i dowcipów, które — jak pokazały wcześniejsze testy — niekorzystnie wpływały na jakość odpowiedzi modelu. Model często zaczynał odpowiadać w stylu komentarzy internetowych albo udzielał odpowiedzi oderwanych od rzeczywistości.

Dodatkowo z portalu Fakt pobrałem metodami web scrapingu 67 846 nowych artykułów, opublikowanych do 12 sierpnia 2025 r. (cutoff date dla tego zbioru danych). Chodziło o aktualizację wiedzy modelu o bieżące wydarzenia, np. objęcie urzędu prezydenta USA przez Donalda Trumpa oraz prezydenta Polski przez Karola Nawrockiego. Testy pokazały, jak ważna jest aktualizacja danych treningowych. To jedno z wyzwań dla twórców modeli językowych. Wiedza tworzonego LLM musi nadążać za stale zmieniającą się rzeczywistością, inaczej udzielane odpowiedzi na tematy bieżące szybko tracą aktualność.

Najważniejszą zmianą było jednak dodanie do zbioru treningowego 616 279 syntetycznie wygenerowanych par pytań i instrukcji wraz z odpowiedziami, przygotowanych podczas wcześniejszych eksperymentów z Mistralem i Gemini.

W efekcie powstał hybrydowy zbiór treningowy, łączący oryginalne teksty źródłowe z syntetycznie wygenerowanymi parami pytań i instrukcji z odpowiedziami. Dzięki temu model uczył się zarówno na naturalnych tekstach, jak i na przykładach bezpośredniej interakcji z użytkownikiem.

Źródła i zbiory tekstów użyte do uczenia Toktumi 2.0:

Pomimo dodania dużego zbioru instrukcji, po usunięciu danych z Wykopu (który był najliczniejszym zbiorem tekstów) plik treningowy zmniejszył się o ok. 25% (jeśli chodzi o liczbę tekstów) oraz o ok. 40% (jeśli chodzi o liczbę znaków, a także tokenów).

Ten krok, jak się później okazało, również przyczynił się do poprawy jakości modelu Toktumi 2.0.

Porównanie rozmiarów zbiorów treningowych Toktumi 1.0 | Toktumi 2.0.

2c. Trening modelu

Następnie wykonałem te same kroki, co przy uczeniu Toktumi 1.0:

• Zredukowałem korpus używanych znaków do 256 (poprzez konwersję UTF-8 → ANSI → UTF-8).
• Oddzieliłem próbki tekstu za pomocą separatora <|endoftext|>.
• Z danych treningowych wydzieliłem plik walidacyjny (plik tekstowy ok 10 MB).
• Na podstawie nowego pliku treningowego przygotowałem nowy tokenizer (vocab_size = 50 000). Należy pamiętać o konsekwencjach takiego kroku: każdy tokenizer ma własny słownik i przypisane tokenom identyfikatory, dlatego nowy tokenizer nie był kompatybilny z tokenizerem Toktumi 1.0. Była to cenna lekcja — od tego momentu zachowałem tokenizer Toktumi 2.0 we wszystkich kolejnych etapach rozwoju modelu.
• Utworzyłem pusty model GPT-2 Medium, tą samą metodą, co wcześniej.
• Rozpocząłem trening, tym razem ustawiając liczbę epok na 8 (mając na uwadze, że w trening Toktumi 1.0 zakończył się w okolicy 6,44 epoki).

Uczenie Toktumi 2.0, obliczone na mniejszą liczbę epok, oraz mniejszy plik treningowy, spowodowały, że cały proces zajął 829 048 kroków, a przejście 8 epok trwało około 11,5 doby (nie licząc technicznych przerw związanych z restartami komputera i wznawianiem treningu z checkpointów) - w porównaniu do około 15 dni (6,44 epoki) dla Toktumi 1.0.

2d. Ocena jakości. Etap 1: Perplexity.

Podobnie jak w pierwszym etapie, weryfikacja modelu przebiegała dwuetapowo. Najpierw zmierzyłem wartość perpleksji (perplexity) dla kolejnych checkpointów, wykorzystując przygotowany wcześniej kod ewaluacyjny. Na poniższych wykresach przedstawiono wyniki dla obu modeli.

Krzywe uczenia obu modeli nieco się różnią. W przypadku Toktumi 1.0 perplexity obniżała się stopniowo, osiągając poziom około 26. Toktumi 2.0 charakteryzował się natomiast gwałtowniejszym spadkiem i szybkim ustabilizowaniem wartości w okolicach 19. Taki przebieg wskazuje na skuteczniejsze dopasowanie Toktumi 2.0 do danych oraz większą spójność generowanych predykcji.

Warto jednak pamiętać, że oba modele były oceniane na różnych zbiorach walidacyjnych, dlatego porównanie należy traktować orientacyjnie.

Porównanie perpleksji w modelu Toktumi 1.0 oraz Toktumi 2.0:

2e. Ocena jakości. Etap 2: Prompting.

Drugim etapem weryfikacji było przetestowanie Toktumi 2.0 na zestawie 150 promptów, tych samych, które wykorzystałem wcześniej do oceny Toktumi 1.0 (zob. Część 1).

Proces testowania zautomatyzowałem za pomocą kodu w Pythonie, który uruchamiał prompty na kolejnych checkpointach i zapisywał odpowiedzi. Następnie wyniki poddawałem własnej, ręcznej ocenie.

Ze względu na dużą liczbę odpowiedzi skorzystałem również z pomocy AI do analizy wyników. Oceny nie zawsze były jednoznaczne, ale po kilku turach porównań udało się wytypować najlepszy checkpoint.

Podobnie jak wcześniej, zastosowałem greedy decoding (top_k = 1), dzięki czemu model generował zawsze tę samą, najbardziej prawdopodobną odpowiedź. Pozwoliło to zachować jednolite warunki testowania.

Pełna lista 150 promptów i odpowiedzi modelu -> ZOBACZ.

2f. Zakończenie treningu

Ostatecznie, za najlepszy uznałem checkpoint-787500, zapisany w okolicach 7,60 epoki.

Na jego podstawie przygotowałem finalną wersję modelu Toktumi 2.0 wraz z tokenizerem.

3. Końcowa ewaluacja modelu

W ostatnim kroku przeprowadziłem końcową ewaluację i porównanie obu modeli Toktumi 1.0 i Toktumi 2.0. Żeby porównanie było spójne, opracowałem i zastosowałem jednolitą metodologię oceny. Każdą odpowiedź klasyfikowałem w dwóch krokach:

KROK 1 — Instruction Following (IF)

Czy model poprawnie rozpoznaje, strukturę wypowiedzi (Instruction Following, IF).

Na przykład: gdy otrzymuje pytanie — czy próbuje na nie odpowiedzieć tak, jak się odpowiada na pytanie; czy gdy otrzymuje instrukcję — czy próbuje odpowiedzieć tak, jak się reaguje na instrukcję; gdy otrzymuje niedokończone zdanie — czy je uzupełnia.

Przykład Toktumi 1.0:

Prompt 05: Wymień trzy warzywa.

Odpowiedź: Wymień trzy warzywa. Te z nich są najbardziej wymagające.

W powyższym przykładzie model Toktumi 1.0 nieprawidłowo odczytał strukturę polecenia. Zamiast wykonać instrukcję i wymienić trzy warzywa, kontynuował wypowiedź, jakby kontynuował prompt. Takie odpowiedzi klasyfikowałem jako NIE.

Przykład Toktumi 2.0:

Prompt 05: Wymień trzy warzywa.

Odpowiedź: - Ziemniaki, pomidory i ogórki. (np. ziemniaki, papryka, cebula).

W powyższym przykładzie model Toktumi 2.0 prawidłowo odczytał strukturę polecenia i wymienił trzy warzywa. Takie odpowiedzi oznaczałem tagiem TAK.

KROK 2 — Factuality (FCT)

W kolejnym kroku sprawdzam, czy odpowiedź jest poprawna, zgodna z faktami i ma sens (Factuality, FCT).

Odpowiedzi zawierające halucynacje, nieprawdziwe informacje lub wewnętrzne sprzeczności klasyfikowałem negatywnie, oznaczając je jako HAL.

Stosowałem przy tym liberalne kryteria oceny — odpowiedzi częściowo poprawne również mogły otrzymać ocenę TAK, jeśli kluczowa część odpowiedzi była prawidłowa.

Przykład Toktumi 1.0:

Prompt 13: Mężczyzna to osoba płci

Odpowiedź: Mężczyzna to osoba płci żeńskiej.

W powyższym przykładzie model Toktumi 1.0 rozpoznał strukturę języka i dokończył zdanie / udzielił odpowiedzi (KROK 1 → TAK). Jednak odpowiedział niezgodnie z prawdą. Takie odpowiedzi oznaczałem jako HAL. Dla uproszczenia, włączam je do tej samej grupy, co halucynacje.

Przykład Toktumi 2.0:

Prompt 13: Mężczyzna to osoba płci

Odpowiedź: Mężczyzna to osoba płci męskiej, która nie jest związana z żadną partią polityczną.

W powyższym przykładzie model Toktumi 2.0 poprawnie rozpoznał strukturę języka i dokończył zdanie / udzielił odpowiedzi (KROK 1 → TAK). Dodatkowo, odpowiedź była zgodna z wiedzą o świecie w części dotyczącej płci, natomiast dodatkowe sformułowanie o „bezpartyjności” potraktowałem jako element uboczny, który nie wpływał istotnie na ocenę poprawności. Przyjąłem podejście liberalne, skupiając się na najważniejszych elementach odpowiedzi, aby kryteria oceny nie były nadmiernie rygorystyczne. Takie częściowo poprawne odpowiedzi również klasyfikowałem jako TAK.

Przykład Toktumi 1.0:

Prompt 62: Czekolada jest

Odpowiedź: Czekolada jest zdrowa, ale niezdrowa.

W tym przypadku model Toktumi 1.0 udzielił odpowiedzi sprzecznej wewnętrznie - zawiera dwa wykluczające się stwierdzenia. Tego typu wypowiedzi traktowałem jako przykład halucynacji i również oznaczałem tagiem HAL.

Tak powstało porównanie jakości obu modeli.

Wyniki Toktumi 1.0

Wyniki Toktumi 2.0

WNIOSKI

• Toktumi 2.0 prezentuje wyższą jakość odpowiedzi niż wersja 1.0.

Wniosek: Ponowne uczenie modelu było słuszną decyzją, a zastosowane usprawnienia przyniosły wyraźną poprawę jakości.

• Największa poprawa dotyczy zdolności do podążania za instrukcją (Instruction Following, IF). Liczba przypadków poprawnego rozpoznania polecenia wzrosła ze 118 do 144. Jednocześnie liczba poprawnych odpowiedzi wzrosła z 85 do 102, czyli o około 20%.

Wniosek: Uczenie Toktumi 2.0 na zestawach Pytanie-Odpowiedź (QA) oraz Instrukcja-Odpowiedź (IA) było skuteczne i przełożyło się na lepsze rozpoznawanie i wykonywanie poleceń.

• W Toktumi 2.0 znacznie ograniczono problem odpowiedzi w stylu komentarzy internetowych — model rzadziej naśladuje chaotyczny, oceniający język użytkowników i znacznie częściej wchodzi w rolę przyjaznego asystenta.

Wniosek: Decyzja o usunięciu komentarzy z Wykopu ze zbioru treningowego była słuszna i poprawiła jakość generowanych odpowiedzi. Pokazuje to, że jakość danych treningowych bywa ważniejsza niż ich ilość.

DODATKOWE SPOSTRZEŻENIA

Toktumi 2.0 znacząco lepiej radzi sobie z poleceniami w formie instrukcji niż wersja 1.0.

[Toktumi 1.0]

Prompt 08: Podaj przykład emocji.

Odpowiedź: Komentarz: Nie ma to jak wmawiać ludziom, że są lepsi od innych.

[Toktumi 2.0]

Prompt 08: Podaj przykład emocji.

Odpowiedź: Przykładem emocji może być radość, radość lub smutek, gdy ktoś jest szczęśliwy i cieszy się z tego, co ma.

Na 14 instrukcji w zbiorze (typu podaj..., wymień...) Toktumi 1.0 poprawnie (IF=TAK) odpowiedział tylko w 1 z 14 przypadków, podczas gdy Toktumi 2.0 zrobił to aż w 13 z 14 przypadków.

Czyli: w zakresie instrukcji Toktumi 2.0 wykazuje ogromny postęp w rozpoznawaniu i wykonywaniu poleceń, w porównaniu z niemal całkowitą nieskutecznością w tym zakresie Toktumi 1.0.

Oba modele nadal wykazywały problemy z wiedzą faktograficzną, nawet w przypadku bardzo prostych pytań.

Dobrą ilustracją jest poniższy przykład z ołówkiem.

[Toktumi 2.0]

Prompt 91: Do czego służy ołówek?

Odpowiedź: Ołówek to jeden z najpopularniejszych przedmiotów codziennego użytku. Jest niezbędny do prawidłowego funkcjonowania organizmu, a także do pracy fizycznej i psychicznej. Jego używanie jest bardzo proste, jednak nie każdy wie, jak się do tego zabrać. Jak się go pozbyć?

Co ciekawe, definicja słowa „ołówek” z Wikipedii znajdowała się w zbiorze treningowym obu modeli. Mimo to model nie potrafił poprawnie odpowiedzieć na tak proste pytanie.

Eksperyment: Po zwiększeniu parametru top_k z 1 do 2 i wprowadzeniu elementu losowości model wygenerował odpowiedź znacznie bliższą oczekiwanej definicji.

Prompt: Do czego służy ołówek?

Odpowiedź: Ołówki to bardzo praktyczne i uniwersalne narzędzia do pisania. Są one nie tylko ozdobą, ale także ułatwiają pisanie tekstów oraz ich czytanie w różnych miejscach na świecie - od Londynu po Los Angeles czy Chicago.

Wniosek: Sama obecność informacji w zbiorze treningowym nie gwarantuje, że model po otrzymaniu zapytania uzna ją za najbardziej oczywistą odpowiedź (w trybie greedy decoding). Eksperyment pokazał również, jak duży wpływ na generowane odpowiedzi mogą mieć ustawienia hiperparametrów i techniki promptowania.

PODSUMOWANIE

W tej części opisałem drugi etap rozwoju modelu Toktumi (Toktumi 2.0), w którym wykorzystałem doświadczenia i wnioski z pierwszego treningu (Toktumi 1.0). Najważniejszą zmianą było przebudowanie zbioru treningowego — usunięcie problematycznych komentarzy internetowych oraz wprowadzenie 616 279 syntetycznie wygenerowanych par pytań i instrukcji wraz z odpowiedziami, przygotowanych z wykorzystaniem modeli Mistral i Gemini.

W efekcie powstał hybrydowy zbiór treningowy, liczący 2 336 162 próbki tekstów, łączący naturalne teksty źródłowe z przykładami interakcji z użytkownikiem. Na jego podstawie przygotowałem nowy tokenizer i ponownie wytrenowałem model GPT-2 Medium od podstaw, na domowej karcie graficznej.

Wyniki potwierdziły, że obrany kierunek zmian był właściwy — w teście 150 promptów liczba poprawnych odpowiedzi wzrosła z 85 do 102, a przypadków prawidłowego rozpoznania polecenia ze 118 do 144.

Eksperyment pokazał, jak duże znaczenie ma jakość i struktura danych treningowych, a nie tylko ich liczba. Mimo mniejszego zbioru tekstów Toktumi 2.0 znacznie lepiej radził sobie z poleceniami i rzadziej naśladował chaotyczny styl komentarzy internetowych.

Największym nierozwiązanym problemem pozostała wiedza faktograficzna. Model nadal często halucynuje i ma trudności z udzielaniem poprawnych odpowiedzi nawet na proste pytania. Uznałem więc, że warto pójść o krok dalej — zamiast ponownie trenować model od zera, kontynuować uczenie Toktumi 2.0 na nowym, przygotowanym syntetycznie zbiorze krótkich pytań, instrukcji i dialogów.

Dalszy rozwój modelu opisuję w Części 3.

Model Toktumi 2.0 w Hugging Face Spaces

Model Toktumi 2.0 można przetestować na platformie Hugging Face Spaces:

https://huggingface.co/spaces/miczac/toktumi-2.0-polish-gpt2

NASTĘPNA CZĘŚĆ

Opis projektu

W ramach projektu własnego postanowiłem stworzyć i wytrenować od podstaw model językowy typu LLM, działający w języku polskim. Projekt ma charakter edukacyjno-badawczy i niekomercyjny, a jego głównym celem było zdobycie praktycznej wiedzy na temat tworzenia i trenowania modeli językowych.

Projekt rozpocząłem w 2023 roku. Zdecydowałem się na architekturę GPT-2, opracowaną przez OpenAI. To jeden z przełomowych modeli językowych, który odegrał ważną rolę w rozwoju generatywnej sztucznej inteligencji. Dzięki publicznej dostępności kodu i wag modelu stanowił dobry punkt wyjścia do eksperymentów w tamtym czasie.

Pomysł był taki, żeby stworzyć podobny model od A do Z, choć w mniejszej skali. Czyli samodzielnie zebrać teksty (web scraping), przeprowadzić czyszczenie danych, przygotować duży zbiór uczący, wypracować optymalny kod uczący, doprowadzić do końca proces uczenia na domowym PC, a następnie znaleźć najbardziej efektywne metody promptowania na gotowym modelu.

W projekcie wykorzystałem język programowania Python oraz biblioteki PyTorch i Transformers.

Projekt ostatecznie został zrealizowany w trzech etapach:

Etap 1 - Toktumi 1.0 (2024): Polegał na stworzeniu i wytrenowaniu od podstaw pierwszej działającej wersji modelu. Wykorzystałem 3 115 002 próbki tekstów pozyskanych z różnych źródeł internetowych i innych materiałów. Przygotowałem własny tokenizer, przeprowadziłem trening i pierwsze testy jakości odpowiedzi.

Etap 2 - Toktumi 2.0 (2025): Był to ponowny trening modelu od zera, z wykorzystaniem poprawionego zbioru uczącego, zawierającego 2 336 162 próbki tekstów. Na podstawie doświadczeń i wniosków z poprzedniego etapu zmodyfikowałem strukturę i zawartość zbioru treningowego.

Etap 3 - Toktumi 3.0 (2026): Fine-tuning modelu Toktumi 2.0 na całkowicie syntetycznym zbiorze liczącym 6 190 420 krótszych rekordów, składającym się wyłącznie z par typu pytanie–odpowiedź, instrukcja–odpowiedź oraz prostych par dialogowych. Celem było rozwinięcie wiedzy faktograficznej modelu, poszerzenie jego możliwości językowych i poprawa jakości generowanych odpowiedzi.

Każdy z trzech etapów szczegółowo opisuję w kolejnych częściach pracy.

ROZDZIAŁ I. Toktumi 1.0. Pierwszy trening.

1. Wybór rozmiaru modelu

Spośród czterech dostępnych rozmiarów GPT-2 (XL, Large, Medium, Small), zdecydowałem się na rozmiar Medium, ponieważ był to rozsądny kompromis pomiędzy posiadanymi zasobami sprzętowymi, a jakością generowanego tekstu. Granicę wyznaczała też ilość posiadanego vram (12 GB) na karcie graficznej NVIDIA RTX 3060. Uczenie modelu GPT-2 Medium w wybranej przeze mnie konfiguracji zużywało około 11 GB. Uznałem to za optymalny wybór.

Dostępne rozmiary modeli GPT-2

• GPT-2 Small: 124M, czyli: 124 miliony parametrów
• GPT-2 Medium: 345M, czyli: 345 milionów parametrów << wybrany model
• GPT-2 Large: 762M, czyli: 762 miliony parametrów
• GPT-2 XL: 1,5B, czyli: 1,5 miliarda parametrów

2. Analiza rozwiązań OpenAI (GPT-2)

Zacząłem od przeanalizowania dostępnych informacji o GPT-2, udostępnionych przez OpenAI w serwisach Hugging Face oraz GitHub, aby wzorować się na rozwiązaniach zastosowanych przez twórców modelu.

Co warto wiedzieć: oryginalny model GPT-2, zaprezentowany przez OpenAI w lutym 2019 roku, był trenowany na zbiorze danych o rozmiarze około 40 GB, o nazwie WebText, [źródło: OpenAI], [źródło: Hugging Face]. Zbiór ten zawierał około 8 milionów próbek tekstu, zebranych ze stron internetowych. Częściowa lista tych adresów została opublikowana na GitHubie. Samego zbioru jednak firma nie udostępniła. Na podstawie dostępnych źródeł można jednak dowiedzieć się czegoś o jego zawartości, jak i o stosowanej przez Open AI metodologii.

Dodatkową inspiracją były też istniejące wówczas modele GPT-2 w języku polskim, które przygotowali Sławomir Dadas polish-gpt2 oraz Dariusz Kleczek papuGaPT2.

3. Zebranie danych

Wybrane źródła:

Do uczenia Toktumi 1.0 użyłem 3 115 002 próbek tekstów, zebranych przeze mnie z następujących źródeł: (Wykop, Wikipedia , Fakt, Pudelek, Polsat News, książki, dowcipy).

Celem było zgromadzenie tekstów reprezentujących żywy, potoczny język i stworzenie modelu, który potrafi prowadzić konwersację na różnorodne tematy, używając stylu mowy potocznej.

Na tym etapie nie wiedziałem jeszcze, jakie rodzaje tekstów najlepiej sprawdzą się w zbiorze treningowym. Dobór materiałów miał więc częściowo charakter eksperymentalny — wiele decyzji podejmowałem metodą prób i błędów, stopniowo poznając możliwości modelu i kierunki jego dalszego rozwoju.

a) Wikipedia - wykorzystałem zasoby (data dump) polskiej wersji Wikipedii, udostępniane przez Fundację Wikimedia do pobrania na licencji Creative Commons CC BY-SA 4.0. Następnie zawartość pliku XML przekonwertowałem do czystego tekstu.

Wyodrębniłem 1 485 976 haseł, z czego ostatecznie wykorzystałem około połowy z nich (718 129) - żeby styl Wikipedii nie 'zdominował' stylu odpowiedzi modelu.

Teksty z Wikipedii mają charakter haseł encyklopedycznych - są bogate w informacje, skupione na faktach, napisane neutralnym językiem, bez emocjonalnego stylu lub przekazywania opinii.

b) Fakt.pl - do pozyskania tekstów wykorzystałem różne metody web scrapingu, służące do automatycznego pobierania i przetwarzania zawartości stron internetowych. W tym celu przygotowałem skrypty w języku Python, korzystając z biblioteki Scrapy oraz dodatku Scrapy-Splash, uruchamianego w kontenerze Docker.

Skrypty automatycznie pobierały artykuły, wyodrębniały ich treść z kodu HTML i zapisywały każdy tekst do osobnego pliku TXT.

W ten sposób zebrałem 573 445 próbek tekstu, gotowych do dalszego przetwarzania i trenowania modelu.

Portal Fakt publikuje teksty o różnorodnej tematyce, zarówno artykuły informacyjne i publicystyczne, jak i treści o bardziej tabloidowym charakterze. Często mają charakter sensacyjny, emocjonalny i zawierają opinie. Można tu znaleźć m.in. artykuły, recenzje, teksty poradnikowe, horoskopy, czyli szeroki przekrój tematów. Teksty tego rodzaju pomagają modelowi osiągnąć bardziej potoczny styl oraz rozszerzyć jego wiedzę o świecie z różnych dziedzin.

Późniejsze testy i doświadczenia pokazały, że jest to jeden z najcenniejszych zasobów tekstów w całym projekcie, przede wszystkim ze względu na przystępny język, różnorodność gatunków wypowiedzi i bardzo szeroki zakres poruszanych tematów.

Mechanizm działania Scrapy:

c) PolsatNews.pl - do pozyskania tekstów z tego portalu użyłem tej samej metody (Scrapy, Splash, Docker).

Wyzwaniem było ustalenie listy adresów URL do pobrania, ponieważ portal jej nie udostępnia. W tym celu przygotowałem w Pythonie crawler, wykorzystujący biblioteki Requests i BeautifulSoup, który automatycznie wyszukiwał linki do artykułów. Zebrane adresy były podstawą do dalszego scrapowania treści z użyciem Scrapy i Splash. W ten sposób zgromadziłem 126 004 próbek tekstu.

Portal Polsatnews to teksty informacyjne o bieżących wydarzeniach krajowych i zagranicznych. Styl newsowy, formalny, rzeczowy. Artykuły zawierają wiadomości z oficjalnych sprawdzonych źródeł. Teksty tego rodzaju pomagają modelowi poszerzyć swoją wiedzę o świecie i nauczyć się posługiwania neutralnym językiem, ale innym niż styl Wikipedii.

d) Pudelek.pl - do pozyskania tekstów wykorzystałem tę samą metodę web scrapingu (Scrapy, Splash, Docker). W ten sposób zebrałem 165 229 próbek tekstu.

Pudelek zawiera teksty o charakterze plotkarskim - krótkie artykuły o celebrytach, gwiazdach i show-biznesie. Pisane charakterystycznym językiem pełnym ironii, złośliwości, często grające na emocjach. Teksty tego rodzaju pomagają modelowi w imitowaniu żywego potocznego języka, a 'pudelkowy' styl od razu łatwo rozpoznać.

Pudelek publikuje też charakterystyczne, często kąśliwe, komentarze użytkowników. Komentarze zostały pobrane razem z treścią artykułów. Ostatecznie jednak ich nie użyłem, ponieważ pojawiają się na stronie w sposób losowy, przez co model, ucząc się na ich podstawie, nie zachowywał logicznego związku pomiędzy promptem a odpowiedzią.

e) Wykop - to popularny portal, na którym użytkownicy dzielą się swoimi internetowymi „znaleziskami”, publikują posty, a inni użytkownicy komentują je i oceniają. W kontekście trenowania modelu uznałem go za cenne źródło tekstów w stylu komentarzy internetowych.

Do pozyskania tekstów wykorzystałem Python oraz bibliotekę Selenium z narzędziem GeckoDriver, umożliwiające automatyzację przeglądarki Firefox. W ten sposób zebrałem 1 413 999 próbek tekstów, obejmujących publikacje wraz z komentarzami użytkowników.

Ostatecznie okazało się, że wykorzystanie komentarzy internetowych, podobnie jak tych z Pudelka, nie było dobrym wyborem. Komentarze często zawierały chaotyczne, obraźliwe lub niezwiązane z tematem wypowiedzi, które negatywnie wpływały na jakość odpowiedzi modelu. Dlatego w kolejnych wersjach Toktumi całkowicie zrezygnowałem z tego źródła danych.

Mechanizm działania web scrapingu z Selenium:

f) Dowcipy - do zbioru uczącego postanowiłem też dodać teksty dowcipów, zebranych z kilkunastu ogólnodostępnych stron internetowych. Był to eksperyment, który miał sprawdzić, czy model nauczy się generować sensowne teksty humorystyczne.

Okazało się jednak, że nauczenie modelu humoru jest znacznie trudniejsze, niż początkowo zakładałem. Wymaga bowiem uchwycenia ironii, gry słów i różnych subtelności językowych. Niespodziewanie jednak dowcipy pomogły modelowi przyswoić strukturę pytanie-odpowiedź (QA), czyli zasadę, że na zadane pytanie należy udzielić odpowiedzi. Tego rodzaju struktura często występuje w dowcipach, podczas gdy pozostałe teksty w zbiorze treningowym na ogół jej nie zawierały.

Po usunięciu duplikatów zebrałem 88 897 dowcipów.

Zbiór wymagał również dodatkowego czyszczenia i filtrowania treści obraźliwych lub nieodpowiednich. Dowcipy często publikowane są bezpośrednio przez internautów, bez odpowiedniej moderacji. Próby usunięcia takich treści nie zawsze przynosiły zadowalające rezultaty. Pokazało to, jak trudne jest przygotowanie wartościowego zbioru treningowego z tekstów pochodzących z otwartych źródeł internetowych.

Do pobierania tekstów wykorzystałem zautomatyzowaną obsługę przeglądarki (Firefox, GeckoDriver, Selenium i Python).

g) Książki - do zbioru na koniec dodałem teksty 285 książek znalezionych w sieci, podzielonych na 29 299 fragmentów. Były to książki typu: instrukcje obsługi, poradniki, książki popularnonaukowe, reportaże, książki kucharskie etc. Celem było dostarczenie dodatkowych, bardziej pogłębionych treści.

Okazało się, że do uczenia nie nadaje się beletrystyka i szeroko rozumiana fikcja: utwory teatralne, poezja, a także napisy do filmów. Jak pokazały testy, model wówczas zaczynał posługiwać się zbyt abstrakcyjnym, wyrwanym z kontekstu, niezrozumiałym językiem, lub mówił stylem powieściowym, który utrudnia swobodną konwersację. Dlatego, przy wyborze tekstów z tej kategorii, ograniczyłem się do twórczości non-fiction i utworów komentujących naszą rzeczywistość.

Teksty książek trzeba było podzielić na mniejsze fragmenty, zachowując przy tym szerszy kontekst wypowiedzi. W tym celu zastosowałem metodę przesuwających się okien „z zakładką” (overlapping sliding window), w której końcówka jednego fragmentu powtarza się na początku kolejnego. Dzięki temu udało się zachować ciągłość tekstu i ograniczyć utratę kontekstu.

Dzielenie danych metodą overlappingu:

4. Stworzenie pliku treningowego (training set)

Każdy tekst zapisywałem do osobnego pliku .txt. Wybrałem ten format ze względu na jego prostotę — pliki tekstowe można łatwo przeglądać, edytować i czyścić, bez konieczności stosowania dodatkowej struktury danych, np. JSON. Umożliwia to łatwiejsze zapanowanie nad zbiorem danych. Dzięki temu można było np. uporządkować pliki według rozmiarów i usunąć te najmniejsze - czyli puste albo nieprzydatne z punktu widzenia uczenia modelu.

Największe pliki .txt, przekraczające 1024 tokenów, dzieliłem na mniejsze części metodą overlappingu.

Z kolei krótsze teksty tego samego typu (np. dowcipy, krótsze artykuły) łączyłem w większe 'paczki', liczące sobie w przybliżeniu 1024 tokenów, aby zbiór do uczenia był dobrze zbilansowany. Każdy tekst wewnątrz był oddzielony separatorem.

Łączenie tekstów tego samego rodzaju w większe pakiety:

Każdy ze zbiorów danych należało też oczyścić. Był to proces bardzo czasochłonny, składający się z wielu etapów, których nie będę w tym miejscu szczegółowo opisywał. Warto jednak podkreślić, że czyszczenie i przygotowanie danych zajmuje najwięcej czasu - więcej niż samo pozyskiwanie danych i trenowanie modelu.

Pokazuje to, jak ogromnych nakładów pracy wymaga ten etap, który początkowo może wydawać się mniej istotny, a w rzeczywistości jest jednym z najbardziej czasochłonnych i kluczowych elementów całego procesu uczenia modelu. Warto pamiętać o zasadzie „Garbage In, Garbage Out” - jakość danych wejściowych ma fundamentalny wpływ na jakość uzyskiwanych wyników.

Kolejnym krokiem była redukcja zbioru wykorzystywanych znaków w zebranych tekstach. W tym celu wszystkie teksty przekonwertowałem z kodowania UTF-8 do Windows-1250 (do 256 znaków) - i z powrotem (aby zachować ich zgodność z narzędziami wykorzystywanymi podczas treningu). Przy takiej konwersji i dodatkowym czyszczeniu, znaki spoza tego zestawu zostały zastąpione lub usunięte.

Dzięki temu model GPT-2 nie musiał przetwarzać wielu nietypowych znaków, które nie wnosiły istotnej wartości językowej. Ograniczenie liczby wykorzystywanych znaków miało również na celu usprawnienie działania tokenizera (w moim przypadku rozmiar słownika to 50 000 tokenów).

Redukcja korpusu znaków podczas konwersji z UTF-8 do ANSI:

W następnym etapie wszystkie pliki .txt z tekstami połączyłem w jeden duży zbiór danych treningowych (training set), który następnie został użyty do uczenia modelu. Każda z ponad 3 milionów próbek tekstu została oddzielona separatorem <|endoftext|> - takim samym, jak zastosowany przez Open AI w oryginalnej wersji modelu GPT-2.

Wydzieliłem też mniejszy zbiór walidacyjny (validation set) - zawierający dane w tym samym formacie, ale które nie powtarzają się w zbiorze treningowym. Wykorzystałem go później do oceny jakości modelu (do pomiaru perplexity).

Metoda podziału tekstów w zbiorze treningowym i walidacyjnym:

ROZMIARY ZBIORU TRENINGOWEGO TOKTUMI 1.0 (bez separatorów):

Liczba próbek tekstu: 3 115 002

Liczba słów: 658 078 092

Liczba znaków: 4 480 020 887

Liczba tokenów: 978 054 512

Rozmiar pliku: 4,46 GB

5. Przygotowanie tokenizera

Tokenizer (tokenizator) to zestaw plików i reguł pomagających modelowi przekształcać tekst na tokeny - czyli mniejsze fragmenty, na które dzieli się tekst. To właśnie na tokenach działa model, zamieniając je na wartości liczbowe, a na końcu z powrotem na tekst. Właściwe przygotowanie tokenizera ma kluczowe znaczenie dla spójności danych, jakości generowanych odpowiedzi i ogólnej wydajności modelu. Źle przygotowany tokenizer może znacznie pogorszyć proces uczenia i jakość generowanych tekstów.

Zamiast korzystać z gotowego tokenizera, zdecydowałem się przygotować własny, dopasowany do języka polskiego, na podstawie dużej próbki zebranych wcześniej tekstów.

Pliki najczęściej wchodzące w skład tokenizera: vocab.json, merges.txt, tokenizer_config.json, special_tokens_map.json, tokenizer.json.

Zawartość pliku vocab.json:

Poniżej kluczowy fragment kodu użytego do utworzenia tokenizera.

Przyjąłem rozmiar słownika vocab_size=50_000, zbliżony do oryginalnego tokenizera GPT-2, który zawierał 50 257 tokenów we wszystkich wariantach modelu.

Do utworzenia tokenizera wykorzystałem biblioteki Tokenizers oraz Transformers.

from tokenizers import ByteLevelBPETokenizer
from transformers import GPT2TokenizerFast

# Utworzenie i trening własnego tokenizera BPE
tokenizer = ByteLevelBPETokenizer()

tokenizer.train(
    files="tokenizer_teksty.txt",
    vocab_size=50_000,
    min_frequency=2,
    special_tokens=[
        "<|endoftext|>",
        "<unk>",
        "[PAD]"
    ]
)

# Zapis słownika i reguł BPE
tokenizer_path = "tokenizer_2025_endoftext"
tokenizer.save_model(tokenizer_path)

# Przygotowanie tokenizera do pracy z Transformers
fast_tokenizer = GPT2TokenizerFast(
    vocab_file=f"{tokenizer_path}/vocab.json",
    merges_file=f"{tokenizer_path}/merges.txt",
    unk_token="<unk>",
    pad_token="[PAD]",
    eos_token="<|endoftext|>"
)

fast_tokenizer.save_pretrained(tokenizer_path)

Po utworzeniu tokenizera należało sprawdzić, czy działa prawidłowo. W tym celu przeprowadziłem testy poprawności kodowania i dekodowania tekstu oraz zweryfikowałem, czy token specjalny <|endoftext|> jest prawidłowo rozpoznawany jako separator. Wszystkie testy zakończyły się pomyślnie.

Proces tokenizacji i jej weryfikacja:

6. Utworzenie pustego modelu GPT-2 Medium

W kolejnym kroku utworzyłem pusty model GPT-2, bez wytrenowanych wag. Konfiguracja modelu (liczba warstw, głowic, wymiar osadzeń, długość kontekstu i rozmiar słownika) są dopasowane do wariantu GPT-2 Medium oraz wcześniej przygotowanego tokenizera. Jest to punkt wyjścia do trenowania GPT-2 od zera.

from transformers import GPT2LMHeadModel, GPT2Config

# Konfiguracja architektury GPT-2 Medium
config_medium = GPT2Config(
    vocab_size=50_000,  # Rozmiar słownika
    n_positions=1024,   # Maksymalna długość sekwencji
    n_ctx=1024,         # Długość kontekstu
    n_embd=1024,        # Wymiar osadzeń
    n_layer=24,         # Liczba warstw
    n_head=16,          # Liczba głowic atencji
    bos_token_id=0,
    eos_token_id=0,
    pad_token_id=2
)

# Inicjalizacja modelu z losowymi wagami
model_medium = GPT2LMHeadModel(config_medium)

# Zapis modelu i jego konfiguracji
model_medium.save_pretrained("GPT2-MEDIUM-empty_new")

7. Trening modelu

Model trenowałem lokalnie, na karcie NVIDIA GeForce RTX 3060 (12 GB VRAM), z wykorzystaniem Pythona, PyTorch, Transformers i CUDA. Jednym z pierwszych wyzwań było dobranie kompatybilnych wersji bibliotek i sterowników — niezgodności często powodowały błędy lub uniemożliwiały wykorzystanie GPU.

Po skonfigurowaniu środowiska należy sprawdzić, czy PyTorch prawidłowo wykrywa CUDA:

import torch

print("Czy CUDA dostępne =", torch.cuda.is_available())

Wykorzystanie GPU znacząco przyspiesza trening modelu w porównaniu z obliczeniami na samym procesorze (CPU).

UCZENIE - PODSTAWOWE WYZWANIA:

Poniżej fragment logu z przebiegu treningu. Wskaźniki po lewej stronie przedstawiają liczbę wykonanych kroków oraz łączną liczbę kroków zaplanowanych w całym treningu (1140000/1771840), co oznacza, że wykonano 1 140 000 kroków z planowanych 1 771 840. Po prawej stronie widoczna jest wartość 'epoch': 6.43, która informuje, że model znajduje się w szóstej epoce. Cały proces uczenia został zaplanowany na 10 epok, więc ogólny postęp na tym etapie wynosi około 64%.

Kluczowe pojęcia pozwalające monitorować postęp uczenia:

• Kroki (steps) określają, ile razy zaktualizowano wagi modelu. Jeden krok obejmuje przetworzenie jednej lub kilku partii danych (batchy), obliczenie błędu i aktualizację parametrów modelu.
• Epoki (epochs) wskazują, ile razy został przetworzony cały zbiór treningowy. Jedna epoka to jedno pełne przejście przez cały zbiór danych uczących. Zazwyczaj potrzeba wielu epok, aby model osiągnął dobrą jakość predykcji.

Zanim powstał ostateczny kod do uczenia modelu, trzeba było przeprowadzić wiele tur testów na mniejszych zbiorach danych (pliki tekstowe około 50-100 MB). Jednym z poważniejszych wyzwań była odpowiedź na pytanie: po ilu epokach zakończyć szkolenie?

Na początku testowałem kod z mechanizmem early stopping i dwoma zbiorami, treningowym (training set) i walidacyjnym (validation set). Automatyczne zatrzymanie uczenia następowało około 7. epoki. Na tej podstawie przyjąłem bezpieczny limit - maksymalnie 10 epok - jako wartość końcową w docelowym kodzie. Ostatecznie zrezygnowałem z mechanizmu early stopping, ponieważ okazał się mało praktyczny przy trenowaniu na dużym zbiorze danych, w wielu turach, gdy proces musiał być dzielony na mniejsze etapy (wiele razy wstrzymywany i wznawiany).

W ustaleniu najlepszego momentu na zakończenie uczenia bardziej praktyczne okazało się mierzenie perpleksji (perplexity), o czym bardziej szczegółowo piszę w dalszej części.

Poniżej najważniejsza część kodu wykorzystanego do treningu Toktumi 1.0, wraz z konfiguracją hiperparametrów.

from transformers import (
    GPT2LMHeadModel, GPT2Tokenizer, TextDataset,
    DataCollatorForLanguageModeling, Trainer, TrainingArguments
)

# Model, tokenizer i dane treningowe
model_path = "GPT2-MEDIUM-empty_new"
tokenizer_path = "tokenizer_2025_endoftext"
train_path = "BIG_UCZ_fin_v2.txt"
output_dir = "GPT2-MEDIUM-Toktumi-1"

model = GPT2LMHeadModel.from_pretrained(model_path)
tokenizer = GPT2Tokenizer.from_pretrained(tokenizer_path)

# Dopasowanie tokenizera do modelu
tokenizer.add_special_tokens({"eos_token": "<|endoftext|>"})
model.resize_token_embeddings(len(tokenizer))

# Przygotowanie danych treningowych
train_dataset = TextDataset(
    tokenizer=tokenizer,
    file_path=train_path,
    block_size=230  # Długość sekwencji dopasowana do pamięci GPU
)

data_collator = DataCollatorForLanguageModeling(
    tokenizer=tokenizer,
    mlm=False  # Uczenie przewidywania kolejnego tokenu
)

# Hiperparametry treningu
training_args = TrainingArguments(
    output_dir=output_dir,
    overwrite_output_dir=True,
    num_train_epochs=10,             # Maksymalna liczba epok
    per_device_train_batch_size=8,   # Wielkość batcha
    gradient_accumulation_steps=3,   # Akumulacja gradientów
    learning_rate=5e-5,              # Współczynnik uczenia
    fp16=True,                       # Mieszana precyzja (oszczędność VRAM)
    save_steps=7500,                 # Zapis checkpointu co 7500 kroków
    save_total_limit=300,            # Limit zapisanych checkpointów
    logging_steps=500,               # Logowanie postępu
    save_safetensors=False
)

# Inicjalizacja treningu
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    data_collator=data_collator
)

# Trening od zera
trainer.train()

# Alternatywnie: wznowienie z ostatniego checkpointu
# trainer.train(resume_from_checkpoint=True)

# Zapis wytrenowanego modelu i tokenizera
model.save_pretrained(output_dir)
tokenizer.save_pretrained(output_dir)

W trakcie procesu uczenia niezwykle przydatna okazała się funkcja automatycznego zapisywania checkpointów (w tym przypadku 'save_steps=7500', czyli co 7500 kroków).

Katalog z checkpointami:

Każdy katalog z checkpointem zawiera pełny stan modelu, a także niezbędne pliki tymczasowe. Dzięki checkpointom możliwe jest wznowienie treningu dokładnie od miejsca, w którym został zapisany. Zapisywanie wielu checkpointów wymaga jednak dużo przestrzeni dyskowej.

Jest to szczególnie istotne w przypadku długiego treningu trwającego wiele dni — kiedy mogą wystąpić przerwy w zasilaniu, konieczność ponownego uruchomienia komputera lub inne nieprzewidziane zdarzenia.

ZAKOŃCZENIE TRENINGU

Ostatecznie, najbardziej optymalnym punktem zakończenia uczenia okazał się checkpoint-1140000, czyli około 6,44 epoki.

Czas treningu: około 380 godzin (ponad 15 dni).

8. Ocena jakości modelu. Perplexity.

Do oceny jakości wytrenowanego modelu GPT-2 Medium wykorzystałem wskaźnik perplexity (perpleksja). Perplexity mierzy, jak dobrze model przewiduje kolejne słowa w sekwencji — im niższa wartość perpleksji, tym lepsze dopasowanie modelu do danych.

Model był oceniany z użyciem wydzielonego wcześniej zbioru walidacyjnego (validation set) czyli danych, których model wcześniej 'nie widział'. Wynik jest obliczany na podstawie funkcji trainer.evaluate(), która zwraca wartość straty (loss).

perplexity = math.exp(eval_results["eval_loss"])

Ze względu na techniczną złożoność tego zagadnienia, skorzystałem z gotowych rozwiązań.

Zastosowane rozwiązanie działa następująco: kod przechodzi kolejno przez zapisane checkpointy i dla wybranych z nich oblicza wartość perplexity. Dzięki temu można oszacować, w którym momencie dalsze uczenie przestaje być opłacalne.

Jak widać na poniższym wykresie, w pewnym momencie spadek perplexity wyraźnie wyhamował, a dalsze trenowanie oznaczałoby duże zużycie zasobów obliczeniowych przy bardzo niewielkiej poprawie. Na tej podstawie podjąłem decyzję o wcześniejszym zakończeniu treningu, zanim uczenie osiągnęło zaplanowane 10 epok.

9. Ocena jakości modelu. Prompting.

Drugim etapem oceny jakości modelu była ewaluacja ludzka, czyli sprawdzenie, jak Toktumi radzi sobie z konkretnymi promptami.

Do testów wykorzystałem greedy decoding — metodę, w której model wybiera najbardziej prawdopodobny kolejny token. Dzięki temu na ten sam prompt otrzymywałem zawsze tę samą odpowiedź, co zapewniało stabilny punkt odniesienia przy porównywaniu checkpointów.

Taki efekt można uzyskać, ustawiając do_sample=False lub, tak jak w moich testach, do_sample=True i top_k=1. Pozostałe parametry pozwalają kontrolować długość odpowiedzi i ograniczać powtarzanie fragmentów tekstu.

Poniżej kluczowy fragment kodu wykorzystanego do generowania i testowania odpowiedzi Toktumi 1.0.

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer

# Wczytanie modelu Toktumi 1.0 i tokenizera
model_path = "GPT2-MEDIUM-Toktumi-1"
model = GPT2LMHeadModel.from_pretrained(model_path)
tokenizer = GPT2Tokenizer.from_pretrained(model_path)

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device).eval()

# Przykładowy prompt
prompt = "Co to jest grawitacja?"
input_ids = tokenizer.encode(prompt, return_tensors="pt").to(device)

# Parametry generowania odpowiedzi
generate_args = {
    "max_length": 256,            # Maksymalna długość: prompt + odpowiedź
    "min_new_tokens": 2,          # Minimum 2 nowe tokeny
    "no_repeat_ngram_size": 2,    # Blokowanie powtarzających się par tokenów
    "repetition_penalty": 1.1,    # Kara za powtarzanie tokenów
    "do_sample": True,            # Włączony tryb samplingu
    "top_k": 1,                   # Wybór tylko najbardziej prawdopodobnego tokenu
    "pad_token_id": tokenizer.eos_token_id,
    "eos_token_id": tokenizer.eos_token_id
}

# Generowanie i dekodowanie odpowiedzi
with torch.no_grad():
    output = model.generate(input_ids, **generate_args)

generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
print(generated_text)

Model udziela najbardziej prawdopodobnej odpowiedzi.

Prompt: Co to jest grawitacja?

Odpowiedź: - To jest siła, która przyciąga przedmioty.

Aby znaleźć najlepszy checkpoint pod względem jakości odpowiedzi na prompty, przetestowałem wybrane checkpointy na zestawie 150 promptów o różnej strukturze: dokończenia zdań, pytania i instrukcje:

• Dokończenia zdań, np. „Warszawa jest stolicą...”, „Ziemia krąży wokół...”. Model na ogół prawidłowo odczytywał, że jest to struktura, w której należy dokończyć zdanie. Często też udzielał prawidłowej lub najbardziej „intuicyjnej” odpowiedzi. Tu zdarzało się najmniej błędów.
• Pytania, zakończone znakiem zapytania, np. „Co to jest planeta?”, „Do czego służy ołówek?”. Model powinien udzielić odpowiedzi na pytanie - tak jak robi to człowiek. Często prawidłowo odczytywał sytuację pytanie-odpowiedź. Często jednak miał problem zarówno ze zrozumieniem struktury (na pytanie trzeba odpowiedzieć), jak i z faktografią oraz wiedzą o świecie (odpowiadał, ale niepoprawnie).
• Instrukcje, np. „Wymień trzy warzywa”, „Podaj przykład pojazdu”. Warto zauważyć, że instrukcja nie jest pytaniem, ale również wymaga odpowiedniej reakcji — w tym przypadku wykonania polecenia lub udzielenia odpowiedzi. Ten typ promptów sprawiał modelowi największą trudność, ponieważ często nie rozpoznawał ich jako formy wymagającej odpowiedzi.

Pełna lista 150 promptów i odpowiedzi modelu Toktumi 1.0 (w konfiguracji 'greedy decoding') -> ZOBACZ.

10. Zakończenie treningu

Po analizie perplexity i wyników testów na 150 promptach, za najlepszy uznałem checkpoint-1140000, zapisany po około 6,44 epoki.

Dalsze uczenie nie przynosiło już wystarczającej poprawy jakości odpowiedzi, dlatego zdecydowałem się zakończyć trening na tym etapie.

Wybrany checkpoint zawiera zapisane wagi modelu. To on stanowi podstawę finalnej wersji Toktumi 1.0.

11. Końcowa ewaluacja modelu

Pozostała jeszcze ewaluacja końcowa i ustalenie, w jakim stopniu model realizuje przyjęte na początku założenia, czyli czy potrafi prowadzić konwersację na różnorodne tematy, używając stylu mowy potocznej.

W tym miejscu ograniczę się tylko do najważniejszych spostrzeżeń. Prezentowane poniżej przykłady były generowane w trybie greedy decoding.

a) Rozpoznanie promptu.

WNIOSKI: Model często rozpoznaje strukturę promptu i generuje poprawną odpowiedź pod względem gramatycznym i składniowym. Używa przy tym właściwie dobranego stylu. Co ciekawe, struktury Pytanie-Odpowiedź model nauczył się głównie ze zbioru z dowcipami - wiele dowcipów ma formę pytania, po którym następuje odpowiedź (puenta). Dzięki temu model przyswoił prostą zasadę: gdy pada pytanie, należy na nie odpowiedzieć.

Prompt: Co to jest grawitacja?

Odpowiedź: - To jest siła, która przyciąga przedmioty.

Prompt: Co robi kucharz?

Odpowiedź: - Smaży kotlety.

Prompt: Warzywa są zdrowe, bo

Odpowiedź: Warzywa są zdrowe, bo zawierają dużo witamin i minerałów.

b) Podstawowa wiedza o świecie.

Gdy prompt jest stosunkowo prosty, dotyczy powszechnie znanych faktów i nie wymaga złożonego rozumowania, model często udziela poprawnej odpowiedzi. Posiada więc ogólną wiedzę o świecie i znajomość podstawowych faktów.

Najlepiej radzi sobie z promptami wymagającymi dokończenia zdania - ta forma jest dla niego najprostsza do zdekodowania.

Prompt: Stolicą Francji jest

Odpowiedź: - Stolicą Francji jest Paryż.

Prompt: Najwyższą górą na świecie jest

Odpowiedź: Najwyższą górą na świecie jest Mount Everest, który ma wysokość 720 metrów.

(choć myli się podając wysokość)

Prompt: Najdłuższą rzeką w Polsce jest

Odpowiedź: Najdłuższą rzeką w Polsce jest rzeka Wisła.

c) Błędne odpowiedzi.

Zdarza się, że model generuje odpowiedź o poprawnej strukturze, lecz niezgodną z prawdą — sprawiając wrażenie, jakby „zmyślał”. Zjawisko to określa się terminem halucynacji. Oznacza ono sytuację, w której model przedstawia nieprawdziwe lub wymyślone informacje tak, jakby były faktami.

Jak pokazują testy, halucynacje częściej pojawiają się w słabiej wytrenowanych modelach, zwłaszcza na wczesnych etapach uczenia. Trochę przypomina to zachowanie człowieka, który nie zna odpowiedzi, ale mimo to próbuje ją odgadnąć.

Prompt: Do czego służy ołówek?

Odpowiedź: - Do czyszczenia akwariów.

Prompt: Z czego robi się mąkę?

Odpowiedź: - Z proszku do pieczenia.

Prompt: Najszybszym zwierzęciem na lądzie jest

Odpowiedź: Najszybszym zwierzęciem na lądzie jest koń.

d) Brak zrozumienia.

Czasem model niewłaściwie odczytuje strukturę pytania albo udziela odpowiedzi wewnętrznie sprzecznej.

Prompt: Księżyc świeci w

Odpowiedź: Księżyc świeci w nocy, a księżyc świeci nocą.

Prompt: Co to jest ogień?

Odpowiedź: - To jest taki mały, biały, czerwony, świecący, czarny, żółty, zielony, niebieski, pomarańczowy, brązowy, fioletowy.

Prompt: Jakie jedzenie przygotowujesz, kiedy masz gości?

Odpowiedź: - Na początku tygodnia.

Dodatkowo: gdy prompt zawiera instrukcje, model bardzo często w ogóle nie potrafi rozpoznać oczekiwanego stylu odpowiedzi.

Prompt: Podziel się swoimi planami na weekend.

Odpowiedź: Horoskop dzienny - Lew. Dzisiejszy dzień przyniesie Ci wiele możliwości do rozwoju osobistego i zawodowego...

(nieoczekiwanie odpowiada w stylu horoskopu)

Prompt: Wymień dwie przyprawy.

Odpowiedź: Wymień dwie przyprawy. To proste!

(cytuje fragment artykułu z Pudelka lub Faktu)

e) Sekcja 'Komentarz:'

Jak wspomniałem wcześniej, teksty z serwisu 'Wykop.pl' zostały dołączone do zbioru treningowego Toktumi 1.0 razem z komentarzami. Był to najliczniejszy zbiór tekstów w zbiorze treningowym (1 413 999 próbek).

Testy pokazały, że komentarze internetowe znacząco pogorszyły jakość generowanych odpowiedzi. Rzadko były na temat, a dodatkowo - pomimo moderacji - nadal zawierały oceniający, obraźliwy język, powielały szkodliwe stereotypy, a nawet zawierały teorie spiskowe.

Model nie tyle błędnie interpretuje polecenie, ile naśladuje styl komentarzy internetowych — często chaotyczny, oceniający i nieodpowiedni dla roli przyjaznego asystenta.

Prompt: Jakie znasz środki transportu?

Odpowiedź: (...)

Komentarz: Nie znam, ale się wypowiem.

Prompt: Co sądzisz o podróżach po Europie?

Odpowiedź: (...)

Komentarz: Nie wiem, czy to dobry pomysł. W Polsce jest dużo taniej niż w Niemczech.

Prompt: Ziemia krąży wokół

Odpowiedź: Ziemia krąży wokół Słońca.

Komentarz: To jest niesamowite, że w XXI wieku ludzie nadal wierzą w takie bzdury. (...) To tak jakby wierzyć, iż Ziemia krąży dookoła Słońca i jest okrągła. Albo, żeby wierzyć w płaską ziemię. No ale przecież ziemia jest płaska, więc ...

12. Rekomendacje i dalsze kroki

Na podstawie zebranych obserwacji opracowałem krótki zestaw rekomendacji dotyczących dalszego rozwoju modelu. Dwie pierwsze zrealizowałem podczas tworzenia kolejnej wersji modelu — Toktumi 2.0.

REKOMENDACJE:

1. Usunięcie komentarzy internetowych ze zbioru treningowego.
2. Przeprowadzanie fine-tuningu modelu (lub ponownego treningu od zera) na zbiorach typu pytanie-odpowiedź (QA) oraz instrukcja-odpowiedź (instruction fine-tuning).
3. Zastosowanie zaawansowanych technik czyszczenia tekstu, skuteczniejsze filtrowanie treści niepożądanych i szkodliwych.
4. Rozważenie użycia modelu GPT-2 o większej liczbie parametrów: GPT-2 Large (762M) albo GPT-2 XL (1,5B). Model GPT-2 Medium może mieć zbyt małą pojemność oraz ograniczony mechanizm uwagi (attention), aby skutecznie gromadzić wiedzę i generować bardziej złożone wypowiedzi. Potencjalną barierą pozostają tu jednak ograniczenia sprzętowe.
5. Użycie modelu o nowszej architekturze, oferującej większe możliwości niż GPT-2. Barierą mogą być jednak ograniczenia sprzętowe oraz wysokie koszty treningu tych bardziej zaawansowanych modeli.

Model Toktumi 1.0 w Hugging Face Spaces

Działanie Toktumi 1.0 można przetestować na platformie Hugging Face Spaces:

https://huggingface.co/spaces/miczac/toktumi-1.0-polish-gpt2

NASTĘPNA CZĘŚĆ