Mistral-Small-3.1-24B-Instruct-2503-quantized.w4a16

vllm serve RedHatAI/Mistral-Small-3.1-24B-Instruct-2503-quantized.w4a16 --tensor_parallel_size 1 --tokenizer_mode mistral

from openai import OpenAI

# Modify OpenAI's API key and API base to use vLLM's API server.
openai_api_key = "EMPTY"
openai_api_base = "http://<your-server-host>:8000/v1"

client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)

model = "RedHatAI/Mistral-Small-3.1-24B-Instruct-2503-quantized.w4a16"


messages = [
    {"role": "user", "content": "Explain quantum mechanics clearly and concisely."},
]

outputs = client.chat.completions.create(
    model=model,
    messages=messages,
)

generated_text = outputs.choices[0].message.content
print(generated_text)

podman run --rm -it --device nvidia.com/gpu=all -p 8000:8000 \
 --ipc=host \
--env "HUGGING_FACE_HUB_TOKEN=$HF_TOKEN" \
--env "HF_HUB_OFFLINE=0" -v ~/.cache/vllm:/home/vllm/.cache \
--name=vllm \
registry.access.redhat.com/rhaiis/rh-vllm-cuda \
vllm serve \
--tensor-parallel-size 8 \
--max-model-len 32768  \
--enforce-eager --model RedHatAI/Mistral-Small-3.1-24B-Instruct-2503-quantized.w4a16

# Download model from Red Hat Registry via docker
# Note: This downloads the model to ~/.cache/instructlab/models unless --model-dir is specified.
ilab model download --repository docker://registry.redhat.io/rhelai1/mistral-small-3-1-24b-instruct-2503-quantized-w4a16:1.5

# Serve model via ilab
ilab model serve --model-path ~/.cache/instructlab/models/mistral-small-3-1-24b-instruct-2503-quantized-w4a16
  
# Chat with model
ilab model chat --model ~/.cache/instructlab/models/mistral-small-3-1-24b-instruct-2503-quantized-w4a16

# Attach model to vllm server. This is an NVIDIA template
# Save as: inferenceservice.yaml
apiVersion: serving.kserve.io/v1beta1
kind: InferenceService
metadata:
  annotations:
    openshift.io/display-name: mistral-small-3-1-24b-instruct-2503-quantized-w4a16 # OPTIONAL CHANGE
    serving.kserve.io/deploymentMode: RawDeployment
  name: mistral-small-3-1-24b-instruct-2503-quantized-w4a16       # specify model name. This value will be used to invoke the model in the payload
  labels:
    opendatahub.io/dashboard: 'true'
spec:
  predictor:
    maxReplicas: 1
    minReplicas: 1
    model:
      modelFormat:
        name: vLLM
      name: ''
      resources:
        limits:
          cpu: '2'			# this is model specific
          memory: 8Gi		# this is model specific
          nvidia.com/gpu: '1'	# this is accelerator specific
        requests:			# same comment for this block
          cpu: '1'
          memory: 4Gi
          nvidia.com/gpu: '1'
      runtime: vllm-cuda-runtime	# must match the ServingRuntime name above
      storageUri: oci://registry.redhat.io/rhelai1/modelcar-mistral-small-3-1-24b-instruct-2503-quantized-w4a16:1.5
    tolerations:
    - effect: NoSchedule
      key: nvidia.com/gpu
      operator: Exists

# make sure first to be in the project where you want to deploy the model
# oc project <project-name>

# apply both resources to run model

# Apply the ServingRuntime
oc apply -f vllm-servingruntime.yaml

# Apply the InferenceService
oc apply -f qwen-inferenceservice.yaml

# Replace <inference-service-name> and <cluster-ingress-domain> below:
# - Run `oc get inferenceservice` to find your URL if unsure.

# Call the server using curl:
curl https://<inference-service-name>-predictor-default.<domain>/v1/chat/completions
        -H "Content-Type: application/json" \
        -d '{
    "model": "mistral-small-3-1-24b-instruct-2503-quantized-w4a16",
    "stream": true,
    "stream_options": {
        "include_usage": true
    },
    "max_tokens": 1,
    "messages": [
        {
            "role": "user",
            "content": "How can a bee fly when its wings are so small?"
        }
    ]
}'

from transformers import AutoProcessor
  from llmcompressor.modifiers.quantization import GPTQModifier
  from llmcompressor.transformers import oneshot
  from llmcompressor.transformers.tracing import TraceableMistral3ForConditionalGeneration
  from datasets import load_dataset, interleave_datasets
  from PIL import Image
  import io
  
  # Load model
  model_stub = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"
  model_name = model_stub.split("/")[-1]
  
  num_text_samples = 1024
  num_vision_samples = 1024
  max_seq_len = 8192
  
  processor = AutoProcessor.from_pretrained(model_stub)
  
  model = TraceableMistral3ForConditionalGeneration.from_pretrained(
      model_stub,
      device_map="auto",
      torch_dtype="auto",
  )

  # Text-only data subset
  def preprocess_text(example):
      input = {
          "text": processor.apply_chat_template(
              example["messages"],
              add_generation_prompt=False,
          ),
          "images": None,
      }
      tokenized_input = processor(**input, max_length=max_seq_len, truncation=True)
      tokenized_input["pixel_values"] = tokenized_input.get("pixel_values", None)
      tokenized_input["image_sizes"] = tokenized_input.get("image_sizes", None)
      return tokenized_input

  dst = load_dataset("neuralmagic/calibration", name="LLM", split="train").select(range(num_text_samples))
  dst = dst.map(preprocess_text, remove_columns=dst.column_names)

  # Text + vision data subset
  def preprocess_vision(example):
      messages = []
      image = None
      for message in example["messages"]:
          message_content = []
          for content in message["content"]:
              if content["type"] == "text":
                  message_content.append({"type": "text", "text": content["text"]})
              else:
                  message_content.append({"type": "image"})
                  image = Image.open(io.BytesIO(content["image"]))

          messages.append(
              {
                  "role": message["role"],
                  "content": message_content,
              }
          )

      input = {
          "text": processor.apply_chat_template(
              messages,
              add_generation_prompt=False,
          ),
          "images": image,
      }
      tokenized_input = processor(**input, max_length=max_seq_len, truncation=True)
      tokenized_input["pixel_values"] = tokenized_input.get("pixel_values", None)
      tokenized_input["image_sizes"] = tokenized_input.get("image_sizes", None)
      return tokenized_input

  dsv = load_dataset("neuralmagic/calibration", name="VLM", split="train").select(range(num_vision_samples))
  dsv = dsv.map(preprocess_vision, remove_columns=dsv.column_names)

  # Interleave subsets
  ds = interleave_datasets((dsv, dst))

  # Configure the quantization algorithm and scheme
  recipe = GPTQModifier(
      ignore=["language_model.lm_head", "re:vision_tower.*", "re:multi_modal_projector.*"],
      sequential_targets=["MistralDecoderLayer"],
      dampening_frac=0.01,
      targets="Linear",
      scheme="W4A16",
  )

  # Define data collator
  def data_collator(batch):
      import torch
      assert len(batch) == 1
      collated = {}
      for k, v in batch[0].items():
          if v is None:
              continue
          if k == "input_ids":
              collated[k] = torch.LongTensor(v)
          elif k == "pixel_values":
              collated[k] = torch.tensor(v, dtype=torch.bfloat16)
          else:
              collated[k] = torch.tensor(v)
      return collated


  # Apply quantization
  oneshot(
      model=model,
      dataset=ds, 
      recipe=recipe,
      max_seq_length=max_seq_len,
      data_collator=data_collator,
      num_calibration_samples=num_text_samples + num_vision_samples,
  )
  
  # Save to disk in compressed-tensors format
  save_path = model_name + "-quantized.w4a16"
  model.save_pretrained(save_path)
  processor.save_pretrained(save_path)
  print(f"Model and tokenizer saved to: {save_path}")

lm_eval \
    --model vllm \
    --model_args pretrained="RedHatAI/Mistral-Small-3.1-24B-Instruct-2503-quantized.w4a16",dtype=auto,gpu_memory_utilization=0.5,max_model_len=8192,enable_chunk_prefill=True,tensor_parallel_size=2 \
    --tasks mmlu \
    --num_fewshot 5 \
    --apply_chat_template\
    --fewshot_as_multiturn \
    --batch_size auto

python3 codegen/generate.py \
  --model RedHatAI/Mistral-Small-3.1-24B-Instruct-2503-quantized.w4a16 \
  --bs 16 \
  --temperature 0.2 \
  --n_samples 50 \
  --root "." \
  --dataset humaneval

python3 evalplus/sanitize.py \
  humaneval/RedHatAI--Mistral-Small-3.1-24B-Instruct-2503-quantized.w4a16_vllm_temp_0.2

evalplus.evaluate \
  --dataset humaneval \
  --samples humaneval/RedHatAI--Mistral-Small-3.1-24B-Instruct-2503-quantized.w4a16_vllm_temp_0.2-sanitized