As Generative AI (AIGC) fundamentally transforms low-level vision tasks, the way we evaluate image quality is undergoing a massive paradigm shift. In modern generative models, the most pressing issue is no longer just blur or noise, but AIGC semantic hallucinations.

To address this, our team (DSS-SQA: Jiajun Wang, Yipeng Sun, Kaiwei Lian) participated in the LoViF 2026 Challenge on Semantic Quality Assessment. We proposed a novel Full-Reference Image Quality Assessment (FR-IQA) framework that explicitly decouples structural fidelity from semantic alignment.

Our method achieved highly competitive results: a Final Score of 0.8469 on the official test phase and 0.9121 on the validation phase, significantly outperforming traditional metrics, deep-feature metrics (LPIPS, DISTS), and even zero-shot large Vision-Language Models (GPT-5.4, Gemini 3.1 Pro).

🛑 The Challenge: "Shortcut Learning" in Semantic IQA

The LoViF 2026 challenge provides a highly timely and critical benchmark. However, modeling this high-level semantic alignment presents significant obstacles.

The extreme scarcity of training data (only 510 pairs) makes deep neural networks highly prone to "shortcut learning". Instead of learning to evaluate semantic alignment, models easily degenerate into evaluating absolute image sharpness. For instance, a model might erroneously predict a high score for a visually pristine but semantically completely unrelated generated image.

Explicit gating constraints and self-supervised structural priors were vital to overcoming this bottleneck.

🧠 Our Solution: The DSS-SQA Architecture

Our proposed solution, DSS-SQA, explicitly decouples structural degradation from semantic hallucinations using a dual-vision backbone (DINOv3 and CLIP).

1. Dual-Vision Siamese Encoders

Recognizing that structure and semantics are orthogonal dimensions, we employ two distinct, frozen pre-trained foundation models:

• Structural Awareness (DINOv3): We utilize the DINOv3-Base vision transformer to extract structure-aware global representations (implemented with the DINOv3 CLS token by default, with patch-token fallback only when needed).

• Semantic Awareness (CLIP): We employ the CLIP-ViT-L/14 vision encoder to extract global, human-aligned semantic embeddings.

2. Element-wise Multiplication Fusion

To fuse these features, we compute the absolute differences for both branches (\(Diff_{s}\) and \(Diff_{c}\)). Crucially, we introduce an Element-wise Multiplication Fusion for the CLIP features. $$ $$

• By default, we apply \(L_{2}\) normalization before the Hadamard product: mult_clip \(=L_{2}(F_{c_ref}) \odot L_{2}(F_{c_dist})\).

• We then replace the raw distorted semantic feature with this multiplication result to force the network to rely on fine-grained semantic interaction.

• The scalar cosine similarity \(S_{cos}\) is also explicitly injected into the concatenated feature vector.

3. Explicit Semantic Gating Mechanism

To directly combat shortcut learning, we designed an explicit semantic gate. During inference (model.eval()) with semantic gating enabled, if the cosine similarity \(S_{cos}\) falls below a threshold (0.4), the gate applies a hard veto by forcefully pushing the predicted logits toward the lowest quality class (Class 0). This ensures the final expected score approaches zero, effectively penalizing visually pleasing but semantically completely hallucinated pairs.

4. Robust Ensemble Strategy

To maximize robustness and prevent overfitting on the extremely small dataset, we utilized a 5-fold stratified cross-validation strategy during training. During the final testing/inference phase, the expected quality scores from all 5 trained models are averaged (Mean Ensemble) to produce the highly stable final output.

📊 Experimental Results

LoViF 2026 Validation Set

Our method significantly outperforms all baseline metrics, proving that decoupling structure and semantics is highly effective in AIGC evaluation.

The Final Score is calculated as \(0.6 \times SROCC + 0.4 \times PLCC\). On the official blind test phase, our model achieved a Final Score of 0.8469.

Zero-Shot Generalization on BAPPS

To demonstrate that our model learns universally applicable quality representations rather than overfitting the small LoViF dataset, we conducted zero-shot evaluations on the BAPPS perceptual dataset.

Despite being optimized for high-level semantic quality, DSS-SQA remains highly competitive with metrics explicitly trained on BAPPS (like LPIPS), proving that our dense DINOv3 representations robustly capture low-level generative artifacts.

💻 Code & Resources

We have open-sourced the complete training and inference pipeline.

• GitHub Repository: atJesse/SIQAv3

If you find our work helpful for your research, feel free to drop a star on GitHub! 🌟

I had the great honor of presenting our recent work, "Explainable Radiologist-Aligned VLM for CT Image Quality Assessment", during the poster session. It was a fantastic experience to share how we used QLoRA to fine-tune MedGemma-4B-IT, enabling it to provide radiologist-level interpretable feedback for CT images.

It was a privilege to connect with fellow researchers and domain experts in the medical AI field. We had some truly thought-provoking discussions about the limitations of current black-box models and exciting future directions for interpretable AI and Neuro-symbolic methods.

I was absolutely amazed by the exceptional quality of the other posters and presentations. Having the chance to interact face-to-face with the authors behind these outstanding works was invaluable and sparked many new ideas for my own upcoming Master's thesis!

A huge thank you to my amazing co-authors and supervisor for their continuous support: Yipeng Sun, Siming Bayer and Andreas Maier. Looking forward to applying these fresh insights to my next research steps!

#BVM2026 #MedicalImaging #ArtificialIntelligence #VLM #GenerativeAI #FAU #DeepLearning #Research

However, fine-tuning these multimodal models has historically been a complex engineering nightmare.

Enter LLaMA-Factory.

This unified framework makes fine-tuning state-of-the-art models accessible to everyone. In this tutorial, I will guide you step-by-step through fine-tuning Qwen2.5-VL-7B-Instruct on a custom image dataset. Whether you are a researcher or a hobbyist, this guide will take you from an empty folder to a working custom VLM.

Prerequisites

Before we begin, ensure you have:

• Hardware: An NVIDIA GPU (24GB VRAM recommended for 7B models using LoRA; A100/H100 is ideal for faster training).
• OS: Linux (Ubuntu/CentOS) or Windows via WSL2.
• Python: Version 3.10 or higher.

Step 1: Environment Setup

We need a clean environment with the specific dependencies for Qwen's visual processing capabilities.

1. Create a Conda environment:

conda create -n qwen_vl_ft python=3.10
conda activate qwen_vl_ft

1. Clone LLaMA-Factory:

git clone https://github.com/hiyouga/LLaMA-Factory.git
cd LLaMA-Factory

1. Install dependencies: This step is crucial. Qwen2.5-VL requires qwen-vl-utils to handle image inputs.

pip install -e .[metrics]
pip install qwen-vl-utils

(Optional but Recommended: Install Flash Attention 2 for faster training if you have an Ampere/Ada GPU like A100/RTX3090/4090):

pip install flash-attn --no-build-isolation

Step 2: Prepare Your Multimodal Dataset

Data preparation for VLMs is slightly different from text-only models. You need to link your text instructions to specific image files.

1. Organize your images

Create a folder named data/my_images inside the LLaMA-Factory directory and put all your training images there (e.g., .jpg or .png files).

2. Create the JSON file

Create a file named data/my_vl_data.json. The format should include an images list containing the path to the image.

Example Format:

[
  {
    "instruction": "Analyze this image and describe the defects found.",
    "input": "",
    "output": "The image shows a crack in the metal surface located at the top left corner.",
    "images": [
      "data/my_images/defect_001.png"
    ]
  },
  {
    "instruction": "What is the text written on the sign?",
    "input": "",
    "output": "The sign says 'Do Not Enter'.",
    "images": [
      "data/my_images/sign_045.jpg"
    ]
  }
]

Note: Ensure the image paths are relative to the LLaMA-Factory root directory or absolute paths.

3. Register the dataset

Open data/dataset_info.json and add your new dataset definition:

"my_vl_dataset": {
  "file_name": "my_vl_data.json",
  "formatting": "alpaca",
  "columns": {
    "prompt": "instruction",
    "query": "input",
    "response": "output",
    "images": "images"
  }
}

Step 3: Download the Base Model

For stability, download the model weights manually before training.

pip install huggingface_hub
# Download Qwen2.5-VL-7B-Instruct
huggingface-cli download Qwen/Qwen2.5-VL-7B-Instruct --local-dir models/Qwen2.5-VL-7B

Step 4: Configure and Run Training (LoRA)

We will use LoRA (Low-Rank Adaptation). This is efficient and perfect for VLMs. We need to create a YAML configuration file.

Create train_qwen25_vl.yaml in the root folder:

### Model Configuration
model_name_or_path: models/Qwen2.5-VL-7B
template: qwen2_vl                     # CRITICAL: Must use 'qwen2_vl' for correct tokenization
trust_remote_code: true

### Method Configuration
stage: sft                             # Supervised Fine-Tuning
do_train: true
finetuning_type: lora
lora_target: all                       # Qwen-VL benefits from training all linear layers
lora_rank: 16
lora_alpha: 16

### Dataset Configuration
dataset: my_vl_dataset                 # Your custom dataset name
cutoff_len: 2048                       # VLMs need longer context for image tokens
overwrite_cache: true
preprocessing_num_workers: 16

### Training Configuration
output_dir: saves/qwen2.5-vl/lora/sft  # Save path
logging_steps: 10
save_steps: 100
plot_loss: true
overwrite_output_dir: true

### Hyperparameters
per_device_train_batch_size: 4         # Adjust based on VRAM (Try 2 if OOM)
gradient_accumulation_steps: 4
learning_rate: 1.0e-4
num_train_epochs: 5.0
lr_scheduler_type: cosine
warmup_ratio: 0.1
bf16: true                             # Use pure bf16 for A100/3090
flash_attn: fa2                        # Use Flash Attention 2

Start the Training: Run the following command:

llamafactory-cli train train_qwen25_vl.yaml

LLaMA-Factory will now handle the complex task of encoding your images into visual tokens and training the LoRA adapter to understand them.

Step 5: Inference (Testing Your Model)

Once training finishes, let's see if the model learned your task. You can use the CLI or the WebUI.

Using the WebUI (Easiest Method):

llamafactory-cli webui

1. Go to the Chat tab.
2. Select the Checkpoint: saves/qwen2.5-vl/lora/sft.
3. Upload an image in the chat box.
4. Type your instruction and see the magic!

Using CLI:

llamafactory-cli chat \
  --model_name_or_path models/Qwen2.5-VL-7B \
  --adapter_name_or_path saves/qwen2.5-vl/lora/sft \
  --template qwen2_vl \
  --finetuning_type lora

Step 6: Merge and Export (Optional)

If you want to deploy your model (e.g., using vLLM or Ollama), you need to merge the LoRA weights into the base model.

Create merge_vl.yaml:

model_name_or_path: models/Qwen2.5-VL-7B
adapter_name_or_path: saves/qwen2.5-vl/lora/sft
template: qwen2_vl
finetuning_type: lora
export_dir: models/Qwen2.5-VL-FinelyTuned
export_size: 5
export_device: cpu   # Use CPU for merging to save VRAM

Run the export:

llamafactory-cli export merge_vl.yaml

Conclusion

Fine-tuning multimodal models used to require specialized knowledge of visual encoders and projector layers. LLaMA-Factory abstracts this away, allowing you to treat images just like another data input.

By following this guide, you have successfully fine-tuned Qwen2.5-VL, one of the most powerful open-source VLMs available, on your own custom data.

Key Takeaways:

1. Dependencies matter: Don't forget qwen-vl-utils.
2. Data format: Ensure your JSON correctly points to your image paths.
3. Template: Always use template: qwen2_vl for this specific model family.

Happy Fine-Tuning!

If you found this tutorial helpful, please share it with your community!

Don't worry. I went through the exact same struggle—configuring SSH keys, getting "Permission Denied" errors, and wondering why PyTorch couldn't see the GPU.

This guide will take you from receiving the email to training on an NVIDIA A100, step-by-step.

Step 1: Accept the Invitation

1. Log in to the FAU HPC Portal using your standard IdM credentials (e.g., abc1234d).

2. Go to User -> Your Invitations and accept the project invitation.

3. Wait overnight. The system runs a synchronization script every night. You usually cannot log in immediately after accepting; your home directory needs time to be created.

Step 2: Generate and Upload Your SSH Key

HPC systems don't use passwords; they use "keys." You need to generate a lock (Public Key) and a key (Private Key).

For Windows (PowerShell) / Mac / Linux:

Open your terminal and run:

ssh-keygen -t rsa -b 4096

1. Press Enter to save it in the default location.

2. Press Enter twice to skip setting a password (useful for automation).

3. Display your public key:

   • Windows: type %userprofile%\.ssh\id_rsa.pub

   • Mac/Linux: cat ~/.ssh/id_rsa.pub

4. Copy everything (starting with ssh-rsa and ending with your username).

Upload to Portal:

1. Go back to the HPC Portal.

2. Go to User -> Your Accounts.

3. Find your HPC account (e.g., abc1234d), click on it, and paste your key into the "Add new SSH Key" section.

4. Wait 15-20 minutes for the key to sync to the servers.

Step 3: Configure VS Code (The "Pro" Setup)

Do not try to use the raw terminal for everything. Use VS Code with the Remote - SSH extension. It allows you to edit code on the server as if it were on your laptop.

The "ProxyJump" Trick

Direct access to GPU nodes (like tinyx) is often blocked from outside the university network. We need to jump through a "gatekeeper" server called csnhr.

1. In VS Code, install the Remote - SSH extension.

2. Click the blue >< icon (bottom left) -> Open Configuration File -> Select your .ssh/config.

3. Paste the following configuration (Replace abc1234d with YOUR HPC username):

# 1. The Gatekeeper (Jump Host)
Host csnhr
    HostName csnhr.nhr.fau.de
    User abc1234d
    IdentityFile ~/.ssh/id_rsa
    IdentitiesOnly yes
    PasswordAuthentication no

# 2. Woody (CPU Frontend - Good for data transfer)
Host woody
    HostName woody.nhr.fau.de
    User abc1234d
    ProxyJump csnhr
    IdentityFile ~/.ssh/id_rsa
    IdentitiesOnly yes

# 3. TinyX (Tier3 GPU Frontend - RUN YOUR EXPERIMENTS HERE)
Host tinyx
    HostName tinyx.nhr.fau.de
    User abc1234d
    ProxyJump csnhr
    IdentityFile ~/.ssh/id_rsa
    IdentitiesOnly yes

4. Save the file.

5. Click the blue >< icon -> Connect to Host -> Select tinyx.

Step 4: Know Your Territory ($HOME vs $WORK)

Once logged in, you need to know where to put your files. This is the most common mistake beginners make.

• $HOME (/home/hpc/...):

  • Size: Very small (100GB).

  • Use for: Config files, scripts, source code.

  • NEVER put: Datasets, Conda environments, or Model checkpoints here. You will run out of space immediately.

• $WORK (/home/woody/...):

  • Size: Huge (1TB+?).

  • Use for: EVERYTHING BIG. Install Miniforge here. Download datasets here.

  • How to find it: Run echo $WORK in the terminal.

Always switch to WORK before doing anything:

cd $WORK

Step 5: Setting Up the Environment (The Right Way)

Do not use the default Python. Do not use Anaconda (it's too bloated). Use Miniforge.

1. Download and Install (in the terminal on tinyx):

    cd $WORK
    wget https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-Linux-x86_64.sh
    bash Miniforge3-Linux-x86_64.sh
   

   • Crucial: When asked for the installation path, ensure it says /home/woody/.... If it says /home/hpc/..., edit it manually!

   • Type yes to initialize.

2. Restart your terminal (close and reopen the terminal pane in VS Code).

3. Create your Environment: (e.g., vlm_env)

    mamba create -n vlm_env python=3.10
    mamba activate vlm_env
   

Step 6: Installing PyTorch (The Trap!)

Here is where many fail.

1. Compute nodes (GPUs) have NO INTERNET. You must install packages on the Login Node (tinyx).

2. Mamba sometimes defaults to CPU versions. Use pip to force the CUDA version.

The Golden Command (run this on tinyx):

mamba activate vlm_env
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install transformers accelerate bitsandbytes

Note: We verify installation on the Login Node, but we run it on the Compute Node.

Step 7: Accessing GPUs

You are currently on tinyx (a shared login node). DO NOT run training here. You must request a Compute Node.

Option A: Interactive Mode (Debugging/Testing)

Use salloc to get a GPU for a short time (e.g., 30 mins).

To check what GPUs are available:

sinfo -o "%20P %G"

(You might see partitions like a100, v100, rtx3080).

To request an A100 (The Beast):

salloc --partition=a100 --gres=gpu:a100:1 --time=00:30:00

To request a V100 (Reliable):

salloc --partition=v100 --gres=gpu:v100:1 --time=00:30:00

Once inside (prompt changes to tgXXX), reactivate your environment and test:

mamba activate vlm_env
python -c "import torch; print(f'CUDA: {torch.cuda.is_available()}'); print(f'Device: {torch.cuda.get_device_name(0)}')"

If it says True and NVIDIA A100, you win!

Option B: Batch Jobs (Real Training)

For long training runs (e.g., 24 hours), create a script called run.sh:

#!/bin/bash
#SBATCH --job-name=vlm_train
#SBATCH --output=logs/%j.out
#SBATCH --partition=a100       # or v100
#SBATCH --gres=gpu:a100:1      # or gpu:v100:1
#SBATCH --time=24:00:00

source $WORK/miniforge3/bin/activate vlm_env
python train.py

Submit it with: sbatch run.sh

Summary Cheat Sheet

1. Connect: VS Code -> tinyx.

2. Workspace: cd $WORK.

3. Install: Run installs on tinyx (Login Node).

4. Debug: salloc ... to get an interactive GPU.

5. Train: sbatch run.sh for long jobs.

Good luck with your experiments! 🚀

📖 Abstract

The assessment of computed tomography (CT) image quality has traditionally relied on manual evaluation by radiologists—a method that is both subjective and time-consuming. While Deep Learning methods exist, they often only give quantitative scores and lack explainability. To address this, we propose a parameter-efficient supervised fine-tuning (SFT) framework for the medical VLM, MedGemma-4B-IT. By employing Quantized Low-Rank Adaptation (QLoRA), we aligned the model's visual perception with expert quantitative judgment.

Our results demonstrate a substantial improvement in correlation with expert scores (SRCC=0.7950, PLCC=0.7907) , significantly outperforming zero-shot baselines like Gemini 2.5 Pro and Gemini 2.5 Flash. Most importantly, our model generates professional textual explanations that emulate the reasoning and explanation style of radiologists.

💡 Motivation: Why Explainable AI for CT?

Diagnostic utility in CT scans depends critically on image quality. Degradation due to noise, artifacts, or insufficient contrast can lead to misdiagnoses and repeated examinations.

• The Problem with Manual Scoring: It is labor-intensive, time-consuming, and prone to inter-observer variability.

• The Problem with Previous AI: Conventional Deep Learning methods (NR-IQA) provide a score but remain opaque, making it difficult to interpret why specific scores are assigned.

• The Problem with Cloud VLMs: General-purpose, closed-source VLMs are often constrained by patient privacy regulations.

Our goal was to create a locally deployable, privacy-preserving, and explainable solution.

🛠️ Methodology: The Framework

We formulated CT-IQA (Image Quality Assessment) as a multimodal reasoning task.

1. The Model Architecture

We selected MedGemma-4B-IT as our base model due to its strong medical priors. The architecture consists of:

• Vision Encoder: SigLIP, to capture local anatomical and noise patterns.

• Multimodal Projector: Aligns visual representations with the language space.

• Language Model: Gemma, generating both the textual reasoning and the final quality scores.

  

2. Parameter-Efficient Fine-Tuning (QLoRA)

To make training efficient, we used QLoRA.

• 4-bit Quantization: The backbone weights are quantized to 4-bit precision and frozen to reduce memory consumption.

• Trainable Adapters: Only the low-rank adapters (~1% of parameters) are trainable.

3. Data Construction with "Teacher" Distillation

Since large labeled datasets with explanations are scarce, we created a novel pipeline using the LDCTIQA dataset (1,000 CT slices):

• Teacher Model: We employed Gemini 2.5 Pro (the best zero-shot performer) to generate expert-level textual explanations for the training data.

• Fine-tuning: We trained our model to mimic these high-quality explanations, pairing them with radiologist scores.

📊 Results

Quantitative Performance

Our fine-tuned model achieved state-of-the-art results compared to zero-shot baselines on the test set.

Data Source: Table 1 in Paper

The fine-tuning improved the SRCC by over +1.0 compared to the original weights.

Qualitative Analysis (Case Study)

In testing, when presented with a low-quality image (Ground Truth Score: 1.2), the zero-shot baseline incorrectly rated it as high quality (3.2).

Our Fine-Tuned Model:

• Predicted Score: 1.0 (Very close to GT 1.2).

• Generated Reasoning: Correctly identified "Severe Artifacts," "Streak Artifacts," and "High Noise". It explicitly noted that streaks were radiating from the pelvic girdle, obscuring tissue texture.

🚀 Conclusion

We demonstrated that a specialized medical VLM can be fine-tuned to emulate the reasoning style of radiologists. This provides a locally deployable, privacy-preserving, and explainable tool for automated CT image quality assessment.

🔗 Resources

• Code: GitHub - VLM-CT-IQA

📝 Citation

If you find this work helpful, please consider citing our paper:

@inproceedings{wang2025explainable,
  title={Explainable Radiologist-Aligned VLM for CT Image Quality Assessment},
  author={Wang, Jiajun and Sun, Yipeng and Bayer, Siming and Maier, Andreas},
  booktitle={German Conference on Medical Image Computing (BVM)},
  year={2026}
}

Engineering Background: Experience in telecommunications and industrial automation, with granted patents for innovative system designs.

AI Research: Published author (BVM Conference) on fine-tuning Vision-Language Models (VLM). Currently researching Diffusion Models for medical image denoising.

Goal: I am actively seeking an internship in AI, Computer Vision, or Deep Learning. I bring a cheerful personality and a strong ability to bridge engineering challenges with advanced AI solutions.

📅 Work and Education History

🔬 Project Research Student

Pattern Recognition Lab, FAU Erlangen-Nürnberg | Oct 2025 – Present

• Focus: Generative AI, VLM, Medical Imaging.

• Key Achievement: Fine-tuned MedGemma-4B using QLoRA for CT image quality assessment.

• Outcome: Paper accepted at the German Conference on Medical Image Computing (BVM). Currently researching Diffusion Models for medical image denoising.

🎓 M.Sc. in Electromobility

Friedrich-Alexander-Universität Erlangen-Nürnberg (FAU) | Oct 2022 – Present

• Specialization: Artificial Intelligence, Deep Learning, and Computer Vision.

• Transitioned from engineering to advanced AI research.

📡 TETRA System Test Engineer

Hytera Communications | Jul 2022 – Oct 2022

• Deployment: Configured TETRA digital trunking systems (BSCU, CHU) for public safety networks.

• Skills: Root cause analysis using Linux, Wireshark, and Xshell.

🎓 B.E. in Automation

Xi'an Polytechnic University | Sep 2018 – Jun 2022

• Major: Automation Engineer Technology.

• Foundation: Built a strong background in Control Systems and Hardware-Software integration.

⚙️ Engineering Intern

Esquel Group | Jul 2021 – Aug 2021

• Innovation: Designed a PLC-based monitoring system using position sensors to track roller displacement.

• Impact: Reduced manual errors and secured 1 Invention Patent & 1 Utility Model Patent.

🛠 Skills

• AI & Deep Learning: PyTorch, LLMs/VLMs (Fine-tuning, RAG), Diffusion Models, PEFT (LoRA/QLoRA), SFT, RLHF, Computer Vision.

• Programming: Python, C, MATLAB.

• Tools & Platforms: Linux, HPC, Docker, Git, Wireshark, Jira.

• Languages: English (Professional), German (Basic), Chinese (Native).

🏔️ Beyond Work

🏃‍♂️ Active Lifestyle

I believe a healthy body fuels a creative mind.

• 🏂 Snowboarding: Passionate about carving through snow in winter.

• 🏊‍♂️ Swimming: Building endurance and focus in the water.

• 🥾 Hiking & Travel: Exploring nature and experiencing diverse cultures.

• 📷 Photography: Capturing life's moments and finding unique perspectives through both modern digital lenses and the timeless charm of classic vintage film cameras.

🥗 Healthy Habits

I maintain a disciplined lifestyle to stay at peak performance.

• 🚭 Substance-Free: Non-smoker and non-drinker.

• 🍬 Conscious Diet: Committed to a low-sugar lifestyle, strictly minimizing refined sugar intake for better health and mental clarity.

❤️ Social Impact

Giving back to the community is an essential part of my life.

• 🧒 Child Development: Deeply care about the growth, education, and well-being of the next generation, actively supporting children's welfare through periodic charitable donations.