FOXES - A Framework for Operational X-ray Emission Synthesis

FOXES - A Framework for Operational X-ray Emission Synthesis

Predicts GOES soft X-ray flux from a 7-channel SDO/AIA solar observation you upload as a NumPy file, and returns a composite image and a flux contribution map. Meant for solar physics researchers.

Made by griffingoodwin04 on Hugging Face. These notes are Mindket's, written from its Space page and README; the app's own files and license are on Hugging Face.

About

What it is: This Space takes a 7-channel SDO/AIA observation and predicts the GOES soft X-ray flux that goes with it. It runs a regression model built on a ViT and returns the flux value, its GOES class, a composite image and a flux contribution map. You supply the observation as a NumPy file.

Who it suits: It suits solar physics researchers and students who work with AIA observations and want a model estimate of soft X-ray flux. Machine learning developers can also read it as a worked example of a patch-based model in a small Gradio app.

Industry | Who uses it | How they use it | Example
Research | Solar physicists | Estimate soft X-ray flux from AIA observations | Give the app one seven-channel observation and read the predicted flux
Space science | Teams that work with solar data | Read the predicted GOES class for an observation | Compare a predicted class with the instrument's own record
Education | Students of solar physics or machine learning | Study a ViT regression model on real solar images | Look at the flux contribution map to see how predicted flux spreads across the image
Software | Machine learning developers | Read app.py and vit_patch_model_local.py | Learn how a patch-based model is wrapped as a Gradio app

If you have no AIA data in seven channels at 512x512, you can skip it.

Where to use it: The app runs in two places.

• A web browser: open the Space page on Hugging Face, where it runs on cpu-basic hardware with nothing to install.
• Python 3.x on Windows, macOS or Linux: start your own copy of the app there.

Use case | Who | What they get back
Predict flux | Researchers | A predicted soft X-ray flux value and its GOES class
See the observation | Anyone with an AIA file | A composite picture built from the 211, 193 and 171 channels
Map the flux | Researchers | A flux contribution map showing where the predicted flux comes from in the image

How to set it up: The online Space needs none of this. For a local copy you need a few things first.

• Python and pip
• A terminal on Windows, macOS or Linux
• A NumPy file holding your AIA observation, since the repository lists no examples folder

These are Hugging Face's steps for a local copy. The repository already holds model.ckpt and normalized_sxr.npy.

1. Install the Hugging Face hub package with pip.
2. Download the Space's files into a folder named FOXES-model.
3. Move into that folder.
4. Install Gradio 5.12.0, then the packages listed in requirements.txt.
5. Start the app.

pip install -U huggingface_hub
hf download griffingoodwin04/FOXES-model --repo-type space --local-dir FOXES-model
cd FOXES-model
pip install gradio==5.12.0
pip install -r requirements.txt
python app.py

How to use it: Start the app, or open the Space page, and upload one .npy file. The file must hold a float32 array of shape (7, 512, 512), one 512x512 image for each of the 94, 131, 171, 193, 211, 304 and 335 Angstrom channels. The app then returns the flux prediction, the composite image and the flux contribution map.

python app.py

Tool | What it does
python app.py | Starts the Gradio app from your downloaded copy

Example: You upload a .npy file with the seven AIA channels for one moment. The app returns a predicted soft X-ray flux in W/m^2 with its GOES class. You also get an RGB picture from the 211, 193 and 171 channels, and a map of how the predicted flux is spread over the image.

For newcomers and experts: The model takes seven views of the Sun in different wavelengths and predicts one number, a soft X-ray flux. Start by preparing a small .npy file in the shape above and uploading it. The repository lists no examples folder, so you bring the file yourself.

Under the hood, the 512x512 input is cut into 8x8 pixel patches, 4096 in all, and a ViT regresses the flux from them. The fixed input shape is the trade-off, because the app only accepts seven channels at that size. The repository also holds fetch_aia.py and fetch_goes.py, and the source does not say how to run them.

You upload a (7, 512, 512) float32 .npy file
The ViT model splits it into 8x8 pixel patches
It regresses the soft X-ray flux in W/m^2
The app shows flux, GOES class, composite and map

Good to know: A few facts are worth checking first.

• Input: one NumPy file of seven channels, each 512x512, stored as float32.
• Hosting: a Space needs normalized_sxr.npy and a model checkpoint beside app.py. Example files are optional.
• License: cc-by-4, as the Space's listing shows.
• Cost to run: none named. The source lists no API key, account or paid service.
• Data it reaches: the .npy file you upload and the files in the repository. The source does not say what fetch_aia.py and fetch_goes.py contact.
• Not for: inputs other than seven-channel 512x512 AIA arrays.

On Hugging Face, 13 November 2026

• Likes: 1
• Built with: gradio
• License: cc-by-4.0

Links

• Space: https://huggingface.co/spaces/griffingoodwin04/FOXES-model
• Files: https://huggingface.co/spaces/griffingoodwin04/FOXES-model/tree/main

Try it

Open the Space in your browser, or copy it to your own Hugging Face account from its page. Nothing in this kit runs by itself.