Instructions to use harshatheg/GPC-1 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use harshatheg/GPC-1 with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("image-text-to-text", model="harshatheg/GPC-1")

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("harshatheg/GPC-1")
model = AutoModelForMultimodalLM.from_pretrained("harshatheg/GPC-1", device_map="auto")

PEFT
How to use harshatheg/GPC-1 with PEFT:
```
Task type is invalid.
```
Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use harshatheg/GPC-1 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "harshatheg/GPC-1"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "harshatheg/GPC-1",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker

docker model run hf.co/harshatheg/GPC-1

SGLang

How to use harshatheg/GPC-1 with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "harshatheg/GPC-1" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "harshatheg/GPC-1",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "harshatheg/GPC-1" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "harshatheg/GPC-1",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Docker Model Runner
How to use harshatheg/GPC-1 with Docker Model Runner:
```
docker model run hf.co/harshatheg/GPC-1
```

GPC-1 / README.md

harshatheg

Release v1

c87a0aa 15 days ago

preview code

Raw History Blame Contribute Delete

6.52 kB

	---
	license: apache-2.0
	base_model: Qwen/Qwen3.5-35B-A3B
	library_name: transformers
	base_model_relation: adapter
	inference: false
	tags:
	- classification
	- structured-prediction
	- multimodal
	- peft
	- lora
	---

	# GPC-1

	Introducing GPC-1, a general-purpose classifier based on Qwen3.5-35B-A3B, post-trained for categorical decisions, bounded numerical estimates, and image-conditioned coordinates.

	Define your labels, numeric ranges, or allowed JSON records through one API. Build document routing, scoring, visual annotation, and structured workflows around outputs your application can use directly. Multiple numeric fields are evaluated in one model pass.

	[Demo](https://huggingface.co/spaces/harshatheg/GPC-1-Demo) · [Get started](#get-started) · [Download options](docs/DOWNLOADS.md) · [API guide](API.md) · [Local demo](demo/README.md) · [Model card](MODEL_CARD.md)

	## Key features

	- Categorical classification: supply your own labels and receive a selected class with probabilities over the available choices.
	- Continuous range selections: specify bounds and a field description to obtain a numerical estimate.
	- Image-conditioned numerical outputs: ask for coordinates using the image and a natural-language description of the target.
	- Dependent structured choices: score complete allowed JSON records together to keep related categorical decisions consistent.
	- OpenAI-style serving: use familiar messages and JSON schemas on NVIDIA hardware.

	## Continuous range selections

	Define the range, units, and reference frame for each numeric field. The same interface can represent a position, angle, distance, or score.

	For example, `0` to `1` can describe a horizontal image coordinate, while `0` to `360` can describe an angle in degrees.

	```json
	{
	"key": "x_coord",
	"description": "Horizontal position of the requested point; 0 is the left edge and 1 is the right edge",
	"minimum": 0,
	"maximum": 1,
	"unit": "image-width fraction"
	}
	```

	Each field uses 101 evenly spaced positions. The API returns the most likely position and a probability-weighted mean that can fall between positions. These are finite-resolution estimates. [Output semantics](API.md#numeric101).

	## Examples

	### Bounding boxes

	Four normalized coordinates define two corners: `x_min`, `y_min`, `x_max`, and `y_max`, with the origin at the image’s top-left. [Image request format](API.md#images).

	![Bounding box predicted by GPC-1 for the runner in red](assets/examples/bounding-box.png)

	### Human pose and keypoints

	Describe a landmark and request its coordinates, such as `right_hip_x` and `right_hip_y`. Each coordinate is a separate numeric estimate; a complete skeleton is not enforced.

	![Human pose example with a tennis player](assets/examples/visual-coordinates.png)

	### Intent classification

	Define intent labels in the request and receive a selected label with probabilities over those labels.

	![Intent-classification example](assets/examples/intent-classification.png)

	### Numerical request

	> “A tank holds 200 liters. It is 35% full. Return the current volume of liquid in liters.”

	Define `volume` over `0–200`, with units `liters`. GPC-1 returns `70` as the most likely value. The same numeric interface can express a rating, distance, fraction, or image coordinate; the prompt supplies the interpretation.

	### Dependent decisions

	Instead of independently choosing a department and an action, provide the complete records your workflow permits. GPC-1 scores those records together, so an invalid combination cannot appear in the returned support. Joint scoring is bounded by the records you enumerate, not arbitrary JSON generation.

	See the [API guide](API.md) for request payloads and response fields.

	## Get started

	Run GPC-1 on compatible NVIDIA hardware with enough memory for the BF16 model. The complete release includes the GPC-1 backbone, its matching adapter, and serving code. The server loads both weight components automatically.

	```bash
	python3 -m pip install "huggingface-hub>=1.7,<2"
	hf download harshatheg/GPC-1 --local-dir gpc-1
	python gpc-1/download.py verify gpc-1
	cd gpc-1
	python3 -m pip install --index-url https://download.pytorch.org/whl/cu130 torch==2.9.1 torchvision==0.24.1
	python3 -m pip install -r requirements.txt
	export GPC1_MODEL_PATH="$PWD/model"
	export GPC1_API_KEY="$(python3 -c 'import secrets; print(secrets.token_urlsafe(32))')"
	python3 -m uvicorn gpc1_server.api:app \
	--host 127.0.0.1 --port 8000 --no-access-log
	```

	Keep the server running. In another terminal, open `gpc-1`, set `GPC1_API_KEY` to the same key used by the server, and send an OpenAI-style request to `/v1/chat/completions`:

	```bash
	curl http://127.0.0.1:8000/v1/chat/completions \
	-H "Authorization: Bearer $GPC1_API_KEY" \
	-H "Content-Type: application/json" \
	--data @examples/atomic_request.json
	```

	The API uses familiar `messages` and `response_format` fields, with a `gpc1` extension for the prediction mode. See [serving and examples](API.md) for numeric ranges, image inputs, joint records, and deployment configuration. The [download guide](docs/DOWNLOADS.md) covers pinned revisions, Python, CI, and offline deployment.

	## At a glance

	\| Model detail \| GPC-1 \|
	\| --- \| --- \|
	\| Backbone family \| Qwen3.5-35B-A3B \|
	\| Packaged weights \| GPC-1 backbone + matching adapter \|
	\| Architecture \| Multimodal mixture of experts \|
	\| Categorical choices \| 2–255 per request \|
	\| Numeric outputs \| 101-point support over a range you define \|
	\| Image interface \| Image-conditioned numeric fields \|
	\| Dependent outputs \| Enumerated joint records \|
	\| Server input ceiling \| 256K tokens (262,144), including compiled schema and image tokens \|
	\| Serving \| NVIDIA / PyTorch, OpenAI-style HTTP API \|
	\| License \| Apache-2.0 \|

	See [context and deployment](API.md#context-window) for hardware requirements and the hosted demo's separate limits.

	## Under the hood

	GPC-1 uses schema-bound scoring to return typed predictions from its multimodal backbone and matching adapter. Numeric fields share one model pass; dependent categorical decisions are scored as complete allowed records.

	[Architecture](docs/ARCHITECTURE.md) · [Model card](MODEL_CARD.md) · [API documentation](API.md) · [Local demo](demo/README.md) · [License](LICENSE) · [Notices](NOTICE)

	GPC-1 inference code is Apache-2.0. The Qwen base retains its upstream license and notices; [third-party attribution](docs/DATA_AND_LICENSES.md) is included with the package.