Imagine you have thousands of street photographs and you need to answer the same questions about each one: how many cars are parked? Is there a sidewalk? How long is the building frontage? Hiring someone to go through every image manually would take weeks. Training a custom computer vision model would take months. But what if you could simply ask an AI model these questions in plain English — and get structured, usable answers back?

That is exactly what Vision-Language Models do. And today, we are releasing UVLM — an open-source tool that makes it easy to load, test, and compare these models, all from a single notebook in your browser.

Vision-Language Models (VLMs) are AI systems that can look at an image and answer questions about it in natural language. Unlike traditional computer vision, which requires training a separate model for every task (one for counting cars, another for detecting sidewalks, a third for classifying buildings), a VLM handles all of these through text prompts. You write a question, attach a photo, and the model responds.

For example, you can ask a VLM: “Count all motor vehicles visible in this image” and it will answer “3”. You can ask the same model “Is there a sidewalk along the street frontage?” and it will answer “yes”. You can even ask it to estimate the length of a building facade in meters — a task that requires the model to identify reference objects (like parked cars), estimate their size, and reason about perspective. All of this from a single model, with no retraining and no labelled dataset.

The catch is that there are many VLM families available (LLaVA, Qwen, InternVL, BLIP-2, and more), and each one works differently under the hood. They use different image encoders, different tokenisation strategies, and different code to run. If you want to know which model is best for your specific task, you normally have to write separate code for each one — a tedious and error-prone process.

UVLM (Universal Vision-Language Model Loader) is a free, open-source tool that lets you load, configure, and compare multiple VLM architectures using the same prompts and the same evaluation protocol — without writing any model-specific code. It runs entirely in Google Colab, which means you do not need to install anything on your computer or own a GPU. A free Google account is all you need.

The idea is simple: you pick a model from a dropdown menu, type your analysis questions into a form, point the tool at a folder of images, and hit run. UVLM handles all the technical details — the processor classes, the tokenisation, the generation settings, the output parsing — and delivers a clean CSV file with one row per image and one column per task. If you want to try a different model, you just switch the dropdown and run again. Same prompts, same images, same output format. Now you can compare.

To demonstrate what UVLM can do, we benchmarked 8 different models on 120 street-level photographs of French urban frontages. Each image was analysed on five tasks: counting vehicles, detecting sidewalks, counting pedestrian entrances, estimating the street frontage length in meters, and classifying the vegetation type. That is 16 model configurations (each model tested in standard and advanced reasoning modes), 120 images, and 5 tasks per image — all processed and compared through UVLM.

The results were revealing. The largest model (LLaVA 34B, with 34 billion parameters) actually ranked last overall. A much smaller model (LLaVA Vicuna 7B) outperformed it significantly and ran on a free Google Colab GPU. The best overall results came from Qwen 32B with chain-of-thought reasoning enabled, which achieved 88% proximity to human expert annotations across all five tasks. Without UVLM, discovering these differences would have required writing and debugging eight separate inference pipelines.

UVLM was designed for anyone who works with images and wants to extract structured information from them at scale — without becoming a machine learning engineer. If you are an urban planner evaluating streetscape quality across a city, UVLM lets you score thousands of street photographs using natural language prompts. If you are an environmental researcher classifying vegetation from field photographs, UVLM lets you test which AI model gives the most reliable results for your specific classification scheme. If you are an infrastructure inspector processing damage assessment photographs, UVLM lets you set up automated counting and scoring tasks and run them across your entire image archive.

The tool is also valuable for AI researchers who need a controlled benchmarking environment. Because UVLM ensures that every model receives exactly the same prompt and is evaluated with the same metrics, it produces fair, reproducible comparisons. The consensus validation feature (running each task multiple times and taking a majority vote) addresses the inherent randomness of AI outputs, and the truncation detection feature flags when a model’s response was cut off before it could finish — a common but often invisible source of errors.

Getting started takes about five minutes. Open the UVLM notebook from GitHub (the link is below), connect to a GPU runtime in Google Colab, and run the first block to load a model. The second block gives you a form where you type your analysis questions — no coding required. The third block processes your images and saves the results as a CSV file on your Google Drive.

The tool currently supports 11 model checkpoints from two major families (LLaVA-NeXT and Qwen2.5-VL), ranging from 3 billion to 110 billion parameters. Models up to 34B can run on a single free-tier Colab GPU with 4-bit quantisation. Advanced features include consensus validation (2–5 runs per task with majority voting), chain-of-thought reasoning for complex tasks, and automatic truncation detection.

UVLM is released under the Apache 2.0 open-source licence. You can use it, modify it, and build on it for any purpose — academic or commercial.

Links

Source code: github.com/perezjoan/UVLM

Paper: arXiv preprint — Perez & Fusco (2026)

UVLM page on this site: urbangeoanalytics.com › Softwares & Algorithms › UVLM

Benchmark dataset: Zenodo — 120 street-view images

Citation

If you use UVLM in your work, please cite:

Perez, J. & Fusco, G. (2026). UVLM: A Universal Vision-Language Model Loader for Reproducible Multimodal Benchmarking. arXiv:2603.13893

Have you ever wanted to experiment with blockchain development but didn’t know where to start? In this beginner-friendly tutorial, we’ll guide you through deploying your very first smart contract on a blockchain testnet using Remix, an in-browser IDE designed for Ethereum-compatible chains. Whether you’re curious about decentralized applications (dApps), NFTs, or simply want to see how code becomes blockchain logic, this guide will get you started — no prior blockchain experience required.

What is a Smart Contract?

A smart contract is a self-executing program that runs on a blockchain. It stores logic and rules in code — such as sending tokens or recording data — and once deployed, it executes automatically when conditions are met. Smart contracts are immutable (can’t be changed once deployed) and transparent, making them ideal for decentralized finance (DeFi), supply chains, governance, and more. Solidity is the main programming language used to write smart contracts for Ethereum. It is a statically typed, contract-oriented language designed specifically for blockchain logic and storage. Because Solidity compiles to EVM bytecode, the same contract can run on any EVM-compatible blockchain — including Ethereum, Polygon, Arbitrum, Optimism, Avalanche, BNB Chain, and many others.

What is Remix and Why Use It?

Remix is a web-based Integrated Development Environment (IDE) designed specifically for writing, testing, and deploying smart contracts in the Solidity programming language. One of its biggest advantages is that it requires no installation or setup — everything runs directly in your browser. Remix integrates seamlessly with MetaMask and supports deployment to Ethereum-compatible testnets like Goerli and Polygon Amoy. It also offers a powerful set of tools for compiling, debugging, and interacting with your contracts, making it an ideal choice for both beginners and experienced developers.

Before deploying a smart contract, you need a wallet connected to an Ethereum test network. If you’re new to MetaMask, start with our beginner guide here:

👉 Getting Started with MetaMask and the Polygon Amoy Testnet
(Use the same installation steps — MetaMask works the same for all EVM chains.)

Once MetaMask is installed and your wallet is set up, you can add the Ethereum Sepolia Testnet. Sepolia is Ethereum’s primary development and testing network. It behaves like mainnet, but uses test ETH (fake ETH) that you can request for free from faucets. Sepolia is ideal for learning and testing smart contracts because it behaves almost exactly like Ethereum mainnet. It mirrors the same architecture, gas mechanics, and transaction flow, which means everything you deploy or test on Sepolia works the same way on Ethereum. Developer tools such as Remix connect to it directly, and because Sepolia is widely supported, stable, and fast, it has become the standard environment for Ethereum development and education. Since Solidity compiles to EVM bytecode, contracts you deploy on Sepolia behave exactly like they will on Ethereum mainnet.

To add Sepolia manually:

1. Open MetaMask

2. Click Add network → Add a network manually

3. Enter the following Sepolia settings:

Network Name: Ethereum Sepolia
New RPC URL: https://rpc.sepolia.org
Chain ID: 11155111
Currency Symbol: ETH
Block Explorer URL: https://sepolia.etherscan.io

Your MetaMask screen should now show the Sepolia network, ready to use. Once saved, you’ll be connected to the Ethereum Sepolia Testnet and can interact with dApps, deploy contracts from Remix, and send test transactions with no real-world cost. Just like Polygon’s Amoy testnet requires test POL tokens, Ethereum Sepolia requires test ETH to pay for transactions. You can get free Sepolia ETH from multiple faucets. I recommend using this one https://sepolia-faucet.pk910.de/

Now that MetaMask is connected to Sepolia, we can look at the smart contract we’ll deploy. Below is a minimal “GoldenBook” contract written in Solidity. It’s a simple on-chain guestbook: anyone can write a message, and the contract stores it permanently on the blockchain. Messages are saved along with the sender’s address and the time they were submitted, and the contract provides a function to retrieve everything that has been written so far.

This contract begins with a simple data structure called Message, which stores who wrote the message, what they wrote, and when they wrote it. All messages are kept in an array called messages, which is stored permanently on-chain. The postMessage function allows anyone to add a new entry; it checks that the message isn’t empty, then records the sender’s address, the text, and the current timestamp. The getAllMessages function returns the full list of stored messages and is marked as a view function, meaning it doesn’t change blockchain state and costs no gas to call. Altogether, this small contract demonstrates the core ideas of Solidity: defining data, writing functions that change state, and exposing read-only views for external applications.

With your contract ready and MetaMask connected to the Sepolia testnet, the next step is to deploy it on-chain. The easiest way to do this is with Remix, Ethereum’s browser-based development environment. Remix allows you to compile your Solidity code, connect directly to MetaMask, and publish your contract to the blockchain in just a few clicks.

Start by opening Remix at https://remix.ethereum.org and creating a new file called GoldenBook.sol, then paste the contract code from the previous section. Once the file is ready, open the Solidity Compiler tab and select the matching compiler version (in this case, 0.8.20). Press Compile to generate the contract bytecode. Remix will instantly show whether the code is valid and ready for deployment.

After the contract compiles successfully, switch to the Deploy & Run Transactions panel. In the “Environment” dropdown, select Injected Provider (MetaMask)—this tells Remix to use the Sepolia network already configured in your MetaMask wallet. Your MetaMask extension will prompt you to connect Remix if it’s the first time. Once connected, ensure that the selected account has Sepolia ETH and that “GoldenBook” appears in the contract selector. Click Deploy, confirm the transaction in MetaMask, and wait for it to be included in a block. You’ll see the deployed contract appear in Remix under “Deployed Contracts,” along with your transaction hash.

At this point, your contract is live on the Sepolia blockchain, but there’s one last step that is highly recommended: verifying your contract on Etherscan. Verification publishes your Solidity source code alongside the deployed bytecode, allowing anyone to inspect, review, or interact with your contract directly from the explorer. This matters because a blockchain contract is transparent by nature—verification proves the code you shared publicly is the same code deployed on-chain, which builds trust and makes your guestbook readable from tools like Etherscan’s contract tab. It also helps with debugging, audits, and integrating with frontends later on.

Once the contract is compiled and deployed through Remix, you can click “View on Etherscan” in the Remix console to inspect the transaction. On the Etherscan page, click the “To” field of the transaction to open your newly deployed contract address. This brings you to the contract’s dedicated page, where you can verify the source code. Verification requires selecting the correct compiler version, license identifier, and pasting your Solidity source code exactly as deployed. For simple contracts like our GoldenBook, you can paste the code directly since it lives in a single file. For more advanced projects—especially those using imports, libraries, or frameworks—you often need to flatten the contract so all the dependent files are merged into one before verification.

Once submitted, Etherscan will match the compiled bytecode with your source code. A successful verification makes your contract’s code readable on-chain and unlocks the “Read” and “Write” tabs, allowing anyone to interact with it directly from the explorer. You can also view the contract deployed in this tutorial at https://sepolia.etherscan.io/address/0x56f245CB65615A482A8Db6086710A49f93869fb6, although testnets sometimes reset, so the contract may no longer exist by the time you read this.

Now that the contract is verified on Etherscan, you can interact with it directly from your browser. When you open the contract page, you’ll see several tabs, including Read Contract and Write Contract. These act as a simple interface for calling the functions you created in your Solidity code.

To add a new entry to the guestbook, go to the Write Contract tab, as shown in the figure below. Before sending a message, click “Connect to Web3” so Etherscan can link to your MetaMask wallet on the Sepolia network. Once connected, open the postMessage section, type your message, and submit the transaction. MetaMask will ask you to confirm—it needs to do this because writing a message modifies the blockchain and therefore requires gas. After confirming, wait a few seconds for the transaction to be mined. Your message is now permanently stored on-chain.

To view what has been written so far, switch to the Read Contract tab. This interface lets you call read-only functions such as getAllMessages without paying any gas, as shown in the next figure. Because read calls do not modify the blockchain, they can be executed instantly and for free. When you click getAllMessages, Etherscan will return the full list of stored messages, including the sender address and timestamp for each entry.

Using these two tabs together allows you to write new guestbook entries and read the entire message history directly through Etherscan, without needing any custom frontend or development tools. This is one of the simplest and most transparent ways to interact with smart contracts on any EVM-compatible blockchain.

At this point, you’ve deployed a smart contract, verified it on Etherscan, and interacted with it directly through the blockchain. This already demonstrates the core mechanics of decentralized applications: public functions, permanent data storage, and transparent state. But the real power of smart contracts comes when you connect them to a user interface. In the next post, we’ll build a simple UI using V0, complete with wallet integration, allowing users to write messages, read the guestbook, and interact with the blockchain through a clean, modern web interface instead of the Etherscan panels. This is where your guestbook begins to feel like a real application.

There are also many ways you can expand the GoldenBook contract itself. You could transform messages into Proof-of-Attendance (POA) NFTs for events or conferences, turning each signature in the guestbook into a collectible token. You could add optional tips, allowing users to attach small amounts of ETH to messages. Or you might include moderation features, message reactions, or event-based unlocks. Solidity gives you full control over on-chain logic, and because the contract is deployed on an EVM-compatible chain, these features will work across the entire Ethereum ecosystem.

It’s worth noting that blockchain and smart contracts also open compelling possibilities for IoT-driven city systems. Sensors can submit environmental data, mobility information, or infrastructure events directly to a secure, tamper-resistant ledger—similar to how our guestbook stores messages. Combined with decentralized identity, multi-sensor validation, or token-based incentives, this approach could support transparent reporting, urban monitoring, or community-driven data collection. Today’s simple guestbook is just a first step, but it illustrates the fundamental mechanism behind many emerging decentralized IoT and smart-city applications.

In the next article, we’ll bring this project to life with a user-friendly interface and wallet connection so anyone can write their message on-chain with a single click.

QGIS, a leading open-source Geographic Information System (GIS), provides an interesting suite of tools for geospatial analysis. Have you ever wondered about controlling QGIS with a Python script ? About calling a specific tool within QGIS from Python? This capability can be useful to integrate processing already available in QGIS within a script of your own without opening the QGIS software directly. In this blog post, we’ll explore how to call QGIS from a Python script in the Jupyter Notebook. Let’s dive in.

If you’re new to Python or Jupyter Notebook, check out our introductory guide to set up a Python environnement using Anaconda. In this tutorial, we assume that you are using the Anaconda distribution of Python. The first step is to open your Anaconda prompt windows and create a Conda environment that includes both QGIS and Jupyter Notebook. On Windows, click on the Start Menu and type “Anaconda Prompt” in the search bar and open it. Within the command prompt, run the line below:

Now, you can activate the newly created Conda environment using the following command, also in the Anaconda prompt windows. Once you activate the qgis_jupyter environment, you’ll have access to QGIS and Jupyter Notebook within the same environment, allowing you to use QGIS functionality directly from your Jupyter Notebooks. If you have an issue with the code above, it means that you need to install QGIS in your newly created environment. Thus, run this conda install -c conda-forge qgis line of code before proceeding further.

And finally, open a Jupiter Notebook within the environnement you just activated

Now that your notebook is open, you can run the code snippet below to set up the interaction with QGIS. Note that even if you don’t need to open the QGIS standalone, you need to have QGIS installed on your machine to interact with it. That’s why we need to specify in the code below the installation directory path of QGIS and initialize it. This ensures that the Python interpreter can locate the necessary QGIS libraries. Additionally, the script initializes the next processing algorithms that will be performed.

The layer contains the building footprints of Grosseto. Provided you put the GeoPackage in the folder where your notebook is located, you can already import and plot the layer, as shown below. For this example, we are working on a subset of 100 buildings.

Now, let’s execute a straightforward algorithm, such as « dissolve, » by invoking the QGIS tool directly within the notebook and visualize the outcome to verify its success. Ensure to specify the location of the Geopackage in the code, along with defining the input and output layers. Subsequently, call the algorithm using the native:dissolve identifier, and adjust its parameters as necessary. The result, named Dissolved_Subset_Grosseto is saved as a new layer in the GeoPackage and ploted in the notebook.

As you can see below the buildings have been perfectly dissolved using the native QGIS algorithm.

This code snippet below demonstrates a workflow in Python using the buffer QGIS algorithm. First, we reproject the input layer to a Cartesian Coordinate Reference System (CRS) suitable suitable for the buffer function. Subsequently, the script iterates through a series of distances, executing the buffer algorithm four times with varying distances (10, 20, 50, and 100 meters). Each buffer operation generates a new layer with the GeoPackage.

Let’s map the different buffers. The code below import the layers we just created with a loop, and plot them in reverse order in order to visualize the overlap using Matplotlib.

Feel free to engage with this post by commenting, asking questions, or providing feedback.