This work addresses the challenge of translating free-form textual descriptions into precise, well-formed Scalable Vector Graphics (SVG). We introduce an end-to-end framework that ingests a natural-language prompt, identifies the visual elements and semantic relationships it implies, and produces syntactically valid SVG markup that closely matches the intended image. To ensure both fidelity and robustness, our method incorporates a constrained reinforcement learning stage, enforcing a subset of SVG tags and attributes, and a specialized reward function that balances structural correctness, semantic alignment, and code compactness. The proposal utilizes the Qwen 2.5 coder model and employs a two-stage approach - first, the model undergoes supervised fine-tuning on the deepseek-svg-dataset to enhance the model's capacity for instruction adherence. Second, to ensure the generated SVG adheres to specific constraints, reinforcement learning using the Group Relative Policy Optimization (GRPO) algorithm is applied. This project aims to develop a robust system capable of translating natural language into valid and constrained SVG code.
The task of translating natural language into vector graphics holds significant potential for creative
expression and programmatic content generation. This project addresses this challenge within the
context of the Kaggle competition ”Drawing with LLMs,” which requires participants to generate SVG
code from textual descriptions. The core approach involves leveraging the reasoning capabilities of
a large language model, specifically the Qwen 2.5 coder model [
The problem addressed in this project is the generation of valid and constrained Scalable Vector Graphics (SVG) code from natural language descriptions. The input to the system is a textual prompt describing an image or graphic. The output is a string of SVG code representing that image. This task is crucial for the ”Drawing with LLMs” Kaggle competition, where submissions are evaluated based on the quality
CEUR
ceur-ws.org and constraint compliance of the generated SVGs. The constraints are: 1) No SVG may be more than 10,000 bytes long. 2) Each SVG may only include elements and attributes from an allowlist, excluding CSS style elements. 3) No SVG may include any rasterized image data or data from external sources. Additionally, the evaluation system requires that an SVG is returned within 5 minutes, and all SVGs are generated in under 9 hours. This problem is interesting due to the complexity of mapping natural language concepts to precise SVG syntax and the added challenge of enforcing strict output constraints.
Qwen 2.5 coder language model, denoted as 0 with parameters 0, on the deepseek-svg-dataset.
The dataset = {( ,
)}=1 consists of examples, where each = ( , ) represents the input, comprising a natural language prompt and a reasoning trace , and is the target SVG code. The goal of supervised fine-tuning is to learn a new set of model parameters log-likelihood of the target SVG code given the input prompt and reasoning trace. that minimizes the negative
Let = ( ,1 , ,2 , ..., , ) be the sequence of tokens representing the SVG code of length . The conditional probability of generating the target sequence given the input and model parameters is: dataset: .
=1
1 =1 ( | ; ) =
∏ ( , | ,< , ; ) ℒ () = − ∑ log ( | ; ) where ,< = ( ,1 , ..., ,−1 ) represents the tokens generated so far.
The objective of supervised fine-tuning is to minimize the following loss function over the entire This minimization is typically performed using gradient descent-based optimization algorithms, such as Adam, to update the model parameters from the initial parameters 0 to the fine-tuned parameters
Stage 2: Reinforcement Learning for Constraint Enforcement using Group Relative Policy
Optimization (GRPO) The second stage aims to further fine-tune the model (now considered
the initial policy 0 = with parameters 0 = ) using reinforcement learning to ensure that the
generated SVG code adheres to the competition’s constraints. We employ the Group Relative Policy
Optimization (GRPO) algorithm[
Let be a natural language prompt sampled from a distribution . The policy (|) represents the probability of the model with parameters generating an SVG code given the prompt . We define a reward function () that assigns a high positive reward if the generated SVG code satisfies all the constraints (size ≤ 10000 bytes, only allowed elements and attributes, no raster or external data) and a lower or zero reward otherwise.
In practice, the GRPO update often involves sampling multiple actions from the current policy for each prompt and comparing their rewards. The goal is then to maximize the expectation represented as the objective function:
GRPO ofers a distinct advantage over traditional reinforcement learning approaches by leveraging relative comparisons rather than relying solely on absolute reward values. This makes GRPO particularly efective and eficient in environments where reward signals are sparse, noisy, or dificult to calibrate. Instead of attempting to estimate the true value of each action, GRPO simply asks whether one action is better than another within a given group, which leads to more stable learning and often faster convergence. This relative perspective aligns well with human feedback scenarios, where explicit numerical rewards may be unavailable but ranking or preference information is easier to obtain. Moreover, by focusing on group-wise preferences, GRPO can exploit more information per training batch—since each group allows for multiple pairwise comparisons—leading to more eficient policy updates. This approach can also mitigate issues like high variance in returns and instability that often plague absolute reward-based methods such as vanilla policy gradients or PPO.
For this project, we will be using the Huggingface Trl library[
All experiments for this project were conducted on a single NVIDIA A100 GPU with 40GB of memory. We utilized the Qwen 2.5 coder model, and experiments were performed with the 7B parameter versions.
Supervised Fine-tuning Setup: For the supervised fine-tuning stage, the Qwen 2.5 coder model was trained on the deepseek-svg-dataset. Each instance of the dataset consist of a prompt, a step-by-step reasoning trace and a ground-truth svg answer. We perform data processing by placing the reasoning traces in think tags <think>...</think> and the SVG in generated tags <answer>...</answer>. We employed the AdamW optimizer with a learning rate schedule that included a warm-up phase followed by a decay. The batch size was set to 256 and the model was trained for 100 steps. The primary goal of this stage was to adapt the already instruction-tuned Qwen2.5 coder model to the task of generating SVG code from natural language prompts and reasoning traces present in the dataset. This process, popularized in the Deepseek paper as cold start enhances the model’s capacity for instruction adherence and to generate responses in a specific format before reinforcement learning is applied.
Reinforcement Learning Setup: Following the supervised fine-tuning, we performed reinforcement
learning using the Group Relative Policy Optimization (GRPO) algorithm on the text2svg-stack dataset[
To train the SVG generation model using reinforcement learning, we adopt a multi-faceted reward strategy. This approach ofers progressive feedback at diferent stages of the generation process, thereby improving the semantic fidelity, structural validity, and aesthetic quality of the outputs. Our reward functions are composed of six types: Tag Count Reward, Format Reward, Byte Length Reward, Semantic Similarity Reward, and Structural SVG Reward.
We encourage the model to adhere to the expected output structure by awarding partial rewards for correctly used tags. Specifically, the tags <think>, </think>, <answer> and </answer> are each rewarded with 0.25, up to a total of 1.0. This soft guidance helps the model learn appropriate response formatting without being overly rigid.
= 0.25 ⋅ <ℎ> + 0.25 ⋅ </ℎ> + 0.25 ⋅ <> + 0.25 ⋅ </>
To enforce generation structure, we apply a soft format reward that checks whether the response matches the regular pattern: <think>.../think> <answer>.../answer>. If this condition is satisfied, a reward of 0.5 is given; otherwise, the reward is 0. = { 0.5, if format pattern is matched 0.0, otherwise
This reward ensures the model respects the byte-size limit of 10,000 bytes for SVG files. Outputs exceeding this limit receive a penalty of −1.0, while compliant outputs receive a reward of 0.5. = { 0.5, if byte_length(SVG) ≤ 10,000 −1.0, otherwise
We evaluate how well the generated SVG image visually aligns with the input text prompt using a
BLIP-based similarity model. The SVG is converted to a PNG, embedded alongside the text, and scored
via cosine similarity. The resulting similarity score in [
= sim(BLIP_embed(text), BLIP_embed(SVG))
This reward checks if the generated SVG begins with <svg and ends with </svg>, which indicates proper encapsulation of the drawing. Correct structure yields a reward of 1.0, otherwise 0.0. struct = { 1.0, if SVG starts with < 0.0, otherwise and ends with < / >
To qualitatively assess the model’s output, Figure 2 shows examples of SVG images generated after the full two-stage training process.
The generated SVGs demonstrate the model’s ability to produce complex geometric shapes with appropriate color gradients, fill styles, and background handling. Despite some variance in aesthetic quality, the outputs successfully adhere to structural and content constraints set by the competition guidelines.
During the initial supervised fine-tuning stage, the Qwen2.5 model was trained on the Deepseek-SVG dataset to learn the mapping from natural language prompts, combined with reasoning traces, to SVG code outputs. Figure 3 shows the training loss history across training steps.
The loss curve demonstrates a rapid and consistent decrease in training loss, stabilizing after approximately 100 steps. The initial high loss indicates the model’s limited understanding of SVG generation at the start. As training progressed, the model quickly adapted, achieving a smooth convergence toward lower loss values around 0.4 to 0.5, indicative of successful learning from the Deepseek-SVG dataset. The stable and decreasing trend suggests that the model was efectively learning the structure and elements of valid SVG code along with the reasoning trace without signs of overfitting or divergence.
Following supervised fine-tuning, the model was further refined using Group Relative Policy Optimization (GRPO) reinforcement learning to enforce strict competition constraints (e.g., maximum file size, allowed elements only, no raster images).
Figure 4 shows the training loss history during the reinforcement learning phase.
The RL loss curve exhibits significantly more instability compared to the SFT phase, characterized by sharp spikes at several points during early training (notably between step 5 and step 20). This behavior is typical in reinforcement learning, where exploration can cause highly variable rewards, especially when the model initially generates SVGs that either strongly violate or partially satisfy the constraints.
After the initial fluctuations, the loss gradually stabilizes toward zero, indicating that the model increasingly produced SVG outputs that conformed to the reward structure defined by the competition rules. The observed instability highlights the challenge of constraint-driven SVG generation, but the eventual stabilization demonstrates that the GRPO method was efective in guiding the model toward constraint-compliant SVG outputs. 4.4. Summary of Model Behavior After Training • After SFT, the model could reliably generate SVG code from prompts but occasionally violated competition constraints (e.g., using disallowed tags). • After GRPO RL, the model’s outputs showed: – Significant improvements in constraint satisfaction rates (near 100% compliance in internal evaluations).
– Improved structural correctness and semantic fidelity of generated SVGs.
Thus, the two-stage training strategy (SFT → GRPO) proved critical for achieving the performance necessary for competitive participation in the Drawing with LLMs Kaggle challenge.
The two-stage training framework combining supervised fine-tuning (SFT) and reinforcement learning (RL) with Group Relative Policy Optimization (GRPO) proved to be an efective strategy for enabling the Qwen2.5 model to generate competition-compliant SVG code from natural language descriptions.
The supervised fine-tuning phase was crucial for teaching the model the foundational mapping between prompts, reasoning traces, and valid SVG outputs. The steady decrease in loss during SFT (Figure 3) suggests that the model efectively learned to replicate the examples in the Deepseek-SVG dataset. However, SFT alone was insuficient to guarantee compliance with the strict competition constraints, such as file size limits, allowed SVG elements, and prohibited raster content.
Reinforcement learning with GRPO addressed this gap by explicitly rewarding the model for producing outputs that satisfied all constraints. Although the RL training curve (Figure 4) showed significant volatility initially—typical for reinforcement learning scenarios—the eventual stabilization demonstrated the model’s ability to adapt under constraint-driven optimization. Nevertheless, RL introduced challenges such as exploration-induced instability and occasional reward hacking attempts, where the model initially found degenerate ways to maximize rewards without improving SVG quality.
In conclusion, the two-stage training process efectively prepared the model for competitive deployment. The project highlights the importance of reinforcement learning when strict structural requirements must be met and demonstrates the synergy between supervised pretraining and rewarddriven refinement.
The generation of vector graphics from natural language descriptions has garnered increasing attention in recent years, building upon advancements in both natural language processing and generative modeling. Several approaches have been explored, ranging from rule-based systems to deep learning models.
Early work in text-to-SVG generation often relied on rule-based systems or template-based methods,
where predefined patterns were mapped to specific linguistic structures. For instance, [
With the rise of deep learning, more sophisticated generative models have been applied to this
task. Recurrent Neural Networks (RNNs) and their variants, such as LSTMs and GRUs, have been
used to directly generate SVG code as a sequence of tokens [
The use of reinforcement learning to guide the output of generative models has also been explored
in various contexts, including text generation. Techniques like policy gradient methods have been
used to optimize models based on non-diferentiable reward signals, such as those related to style,
lfuency, or adherence to specific constraints [
This project distinguishes itself from prior work by combining the strong reasoning capabilities of the Qwen 2.5 model, a state-of-the-art large language model, with a targeted reinforcement learning approach using GRPO to ensure strict adherence to the competition’s constraints. While previous work has explored either direct generation of SVG using sequence models or the use of reinforcement learning for guiding generative models, this project specifically focuses on a two-stage approach that leverages the strengths of both supervised learning on a relevant dataset and reinforcement learning for fine-grained control over the output format and content, particularly in the context of a real-world competition with specific requirements.
During the course of this research, the Qwen 2.5 and Gemma language models were utilized to perform evaluation experiments through the HuggingFace Transformers library. These tools were applied strictly within the context of experimental assessment as described in the methodology. No generative AI systems were employed for the writing or editing of this manuscript. The author assumes full responsibility for the accuracy and integrity of the publication’s content.