🚀 TinyLlama Fine-Tuning with LoRA (CPU-Friendly)

João Bosco — Sat, 21 Jun 2025 19:33:48 +0000

TinyLlama Fine-Tuning with LoRA

This project demonstrates how to fine-tune the TinyLlama-1.1B-Chat-v1.0
model using the LoRA (Low-Rank Adaptation) technique for efficient parameter-efficient training. The training is optimized for CPU environments with limited RAM (e.g., 16GB).

Project Structure

src/TrainTinyLlama.py: Main script for fine-tuning TinyLlama with LoRA.
dataset/dataset.json: Training data in JSON format.

Dataset Format

The dataset should be a JSON file containing a list of objects, each with input and output fields. Example:


  {
    "input": "Generate a form  with a panel with color white",
    "output": {
                "Type": "TForm",
                "Name": "FrmMainForm",
                "Caption": "Sample Form",
                "Width": 800,
                "Height": 600,
                "Children": [
                  {
                    "Type": "TPanel",
                    "Name": "Panel1",
                    "Left": 10,
                    "Top": 10,
                    "Width": 200,
                    "Height": 100,
                    "Color": "#FFFFFF"
                  }
                ]
              }
  }

Fine-Tuning Details

Model: TinyLlama-1.1B-Chat-v1.0
Adapter: LoRA (Low-Rank Adaptation)
Target Modules: q_proj, v_proj
LoRA Config: r=8, alpha=16, dropout=0.05
Batch Size: 1 (adjustable)
Epochs: 1 (increase for better results)
Device: CPU only (use_cpu=True)

Training

To start fine-tuning, run:

python src/TrainTinyLlama.py

The script will:

Load and preprocess the dataset.
Apply LoRA adapters to the model.
Train using Hugging Face's Trainer API.
Save the fine-tuned model and tokenizer to the TinyLlama-lora-out directory.

Output

Fine-tuned Model: Saved in TinyLlama-lora-out/
Logs: Saved in logs/

Requirements

Python 3.8+
transformers
datasets
peft
torch

Install dependencies:

pip install -r src/requirements.txt

Merge LoRA weights into base model

python src\Merge_lora.py

Convert to gguf

python convert_hf_to_gguf.py ../TinyLlama-merged --outfile ./tinyllama-custom.gguf

Import to Ollama

Windows > %USERPROFILE%.ollama\models

Create a Modelfile
FROM ./tinyllama-custom.gguf

ollama create tinyllama-custom -f Modelfile

llama.cpp

The .gguf format is compatible with llama.cpp, a C++ project for efficient execution of Llama models on CPU and GPU.
To use your custom model with llama.cpp, simply copy the .gguf file to the models folder and follow the instructions in the repository.
Documentation: llama.cpp README
Model conversion: convert.py

Example usage:

./main -m ./tinyllama-custom.gguf -p "Your prompt here"

Notes

The script is optimized for CPU training. For GPU, set no_cuda=False and adjust fp16 as needed.
LoRA enables efficient fine-tuning with minimal memory usage.
Adjust hyperparameters (epochs, batch size) based on your hardware and dataset size.

References

🚀 BuilderUI: Create Delphi Interfaces Dynamically from JSON

João Bosco — Thu, 19 Jun 2025 13:33:17 +0000

Have you ever found yourself copying and pasting the same UI code across multiple Delphi forms? I did — and that’s exactly why I created BuilderUI.

BuilderUI is a dynamic UI generator for Delphi that allows you to define components using JSON and render them at runtime. It’s perfect for scenarios where flexibility, rapid prototyping, or low-code customization is needed.

🔧 What is BuilderUI?

BuilderUI is a Delphi engine that reads a JSON file and builds a fully working VCL form with components like:

TEdit, TLabel, TButton, TCheckBox, TComboBox
Containers like TPanel
Event support like OnClick

✅ Main Features:

JSON-driven UI generation
Component positioning (Top, Left, Width, Height)
Runtime event handling
Clean and extensible architecture

🧪 Example JSON Input

{
  "Name": "FrmLoginScreen",
  "Type": "TForm",
  "Caption": "Login Screen",
  "Width": 400,
  "Height": 300,
  "Components": [
    {
      "Type": "TLabel",
      "Name": "lblUser",
      "Caption": "Username",
      "Top": 20,
      "Left": 20
    },
    {
      "Type": "TEdit",
      "Name": "edtUser",
      "Top": 40,
      "Left": 20,
      "Width": 200
    },
    {
      "Type": "TButton",
      "Name": "btnLogin",
      "Caption": "Login",
      "Top": 80,
      "Left": 20
    }
  ]
}

🧠 How It Works (Under the Hood) BuilderUI uses:

🏗️ Builder + Factory pattern to create UI elements
🔁 RTTI to dynamically instantiate and set component properties
🔎 System.JSON for JSON parsing
🧪 In-progress unit tests using DUnitX

💡 Why BuilderUI?

Use cases:
Generate dynamic admin panels from metadata
Let clients define UI layouts via config
Create low-code solutions inside Delphi
Replace boilerplate screen generation with flexible runtime forms

🧭 Roadmap

Grouping and tabs with TPageControl
Data-aware components with binding
Drag-and-drop form designer
Integration with 3rd-party components (DevExpress, TMS)
JSON schema validation and autocomplete

⚙️ How to Use

Want a quick demo? Just clone the repo and run the example project.

Clone the repository: git clone https://github.com/boscobecker/BuilderUI.git
Open in Delphi (tested on Delphi 10.4 and 11+)
Load a JSON file with layout
Run the project and see the form created at runtime

🙌 Contribute or Give Feedback

This project is under active development.
If you're passionate about runtime UI, low-code, or just love Delphi — I'd love your feedback, ideas or contributions.
⭐ Star the project on GitHub
💬 Comment here or open an issue
🤝 Connect with me on LinkedIn :https://www.linkedin.com/in/boscobecker/
🔗 GitHub Repo: https://github.com/boscobecker/BuilderUI

🧠 Follow me for more Delphi & .NET content!

DEV Community: João Bosco