The hardware and bandwidth for this mirror is donated by METANET, the Webhosting and Full Service-Cloud Provider.
If you wish to report a bug, or if you are interested in having us mirror your free-software or open-source project, please feel free to contact us at mirror[@]metanet.ch.

ggmlR 0.7.0

Vignettes: prebuilt HTML via Rcpp::asis

• Seven vignettes (Autograd Engine, Data Parallel Training, Embedding ggmlR, GPU Vulkan Backend, Keras-like API, ONNX Import, Quantization) are now shipped as prebuilt HTML using the Rcpp::asis vignette engine. No rendering on CRAN runners.
• Removed rmarkdown from Suggests (no longer needed).

Test suite

• Suppressed spurious stdout/stderr output from tests: ggml_graph_print() output captured in test-graph-utils.R; C-level broadcast warnings captured in ONNX broadcast and resize-broadcast tests.

ggmlR 0.6.9

GGUF file reader

• gguf_load(path) — opens a GGUF file (v2/v3) and reads all metadata and tensor descriptors. Returns an S3 object of class "gguf".
• gguf_metadata(x) — returns all key-value metadata pairs as a named list (architecture, tokenizer config, quantization info, etc.).
• gguf_tensor_names(x) — lists all tensor names in the file.
• gguf_tensor_info(x, name) — returns shape, type, and size in bytes for a single tensor.
• gguf_tensor_data(x, name) — dequantizes (if needed) and returns tensor weights as an R numeric array with correct dimensions.
• gguf_free(x) — explicitly frees GGUF context (also called by GC).
• Supports all ggml quantization types (F32, F16, Q4_0, Q8_0, K-quants, etc.) with automatic dequantization to F32.
• print.gguf() method shows file version, tensor count, and metadata count.

Vulkan backend: revert to Vulkan 1.2 + Push Descriptors

• Vulkan API version capped at 1.2 (was 1.3). Requesting a Vulkan 1.3 instance implicitly enables Synchronization2 (core in 1.3), which causes significant performance degradation on RADV (Mesa) drivers — particularly on newer AMD hardware (RX 9070 and similar). Capping at 1.2 avoids the implicit promotion while retaining all functionality.
• Push Descriptors (VK_KHR_push_descriptor): unchanged — when the extension is available and maxPushDescriptors >= 12, descriptor sets are pushed directly into the command buffer via pushDescriptorSetKHR(), eliminating descriptor pool overhead. Falls back to the traditional descriptor pool path on hardware without the extension.

Keras-compatible API

• fit() now accepts a callbacks parameter for sequential models (passed through to ggml_fit_sequential()).

Test suite

• New test files: test-gguf.R, test-graph-utils.R, test-inplace-ops.R, test-keras-api.R, test-misc-ops.R, test-model-ops.R, test-print-methods.R, test-tensor-utils.R, test-threading.R, test-autograd-missing.R, test-nn-functional-missing.R, test-quants-missing.R.

ggmlR 0.6.8

Bug fixes

• Fixed ABI mismatch between src/ and inst/include/ headers: configure and configure.win now automatically sync all public headers from src/ to inst/include/ at install time. Previously, changes to GGML_MAX_DIMS (4→5) and other structs in src/ggml.h were not propagated to the exported headers, causing segfaults in downstream packages (e.g. sd2R).
• Added tests/testthat/test-headers-sync.R to verify that inst/include/ headers remain in sync with src/ headers and that GGML_MAX_DIMS is consistent.

ggmlR 0.6.7

ggml engine: native 5D tensor support

• ggml_view_5d() — new API function for creating 5D views with explicit strides, extending the existing 1D–4D view family. Uses the existing ggml_view_impl() internally.
• ggml_repeat_5d() — new API function for tiling tensors up to 5D. CPU kernels (ggml_compute_forward_repeat_f32, ggml_compute_forward_repeat_f16) updated with a 5th loop dimension. Vulkan dispatch collapses dim3×dim4 into push constants transparently (no shader changes needed — push constants remain at 128 bytes).
• ONNX tensor pipeline upgraded from hardcoded 4D to 5D throughout onnx_ggml.c (~20 sites):
  • Initializers, inputs, Constant, ConstantOfShape: ne[GGML_MAX_DIMS] arrays, switch with case 5: new_tensor_5d.
  • Broadcast (onnx_broadcast_align): all reshape/new_tensor calls use dimension-aware helpers.
  • Softmax: reshape-back via generic onnx_reshape_nd().
  • Reshape op: collapse threshold raised from >4D to >5D.
  • Slice: 5D view/offset support, generic stride-based cval propagation and deferred fill.
  • Split: 5D view support.
  • Expand: 5D broadcast with rank promotion.
  • Tile: uses ggml_repeat_5d().
  • Gather axis=0: generic reshape-back for any rank.
  • tmap_put_nd() and slice_fill arrays updated to GGML_MAX_DIMS.
• New internal helpers: onnx_reshape_nd(), onnx_new_tensor_nd(), ne_product() — eliminate switch/case duplication.
• Resize/Interpolate remains 4D (spatial op, 5D not relevant). Transpose/Permute remains 4D (ggml_permute API limitation).

ONNX: ConstantOfShape INT64/INT32/DOUBLE value fix

• roberta-9 model now loads and runs (was producing NaN in softmax). Root cause: ConstantOfShape read the value TensorProto attribute as float regardless of data_type. When data_type=7 (INT64), the 8-byte int64 was reinterpreted as a 4-byte float, producing garbage values (~1.4e-45 instead of 1). This broke attention mask generation (fill=0 instead of 1) and position ID generation (NonZero on zeros = empty).
• Fix: ConstantOfShape now checks data_type and correctly handles INT64, INT32, DOUBLE, and FLOAT value attributes.

ONNX: Gather axis=0 on rank>2 tensors

• Gather on 4D tensors no longer asserts. Previous code always used ggml_get_rows which only supports 2D data. For axis=0 on rank>2 (e.g. CaiT QKV split on [48,576,6,3]), the tensor is now reshaped to 2D, gathered, and reshaped back.

ONNX: ScatterElements op (GPU + CPU)

• New GGML_OP_SCATTER_ELEMENTS added to the ggml engine with both CPU kernel and Vulkan compute shader.
• Vulkan shader (scatter_elements.comp): two variants compiled at install time — scatter_elements_none (overwrite) and scatter_elements_add (atomicAdd via GL_EXT_shader_atomic_float). Data is copied to output via vkCmdCopyBuffer with a pipeline barrier before the scatter dispatch.
• CPU kernel: single-threaded scatter with memcpy (overwrite) or element-wise addition (reduce=add).
• ONNX mapper: ScatterElements op with axis=0 and reduction="none"/"add" attributes. Indices cast to I32, updates/data cast to F32 automatically.
• This unblocks sageconv (GNN message passing with scatter-add).

Model count

• 12/15 ONNX Model Zoo models now pass (was 11/15). New: roberta-9.
• Remaining failures: sageconv (ScatterElements shape mismatch needs further work), cait_xs24_384 (reshape size mismatch), MaskRCNN-12-int8 (spatial broadcast mismatch), xcit_tiny (broadcast dim mismatch).

ggmlR 0.6.6

ONNX: BoTNet RelPosBias2D fused custom op

• botnet26t_256 model now loads and runs (was failing on 5D Transpose in pos_embed subgraph). Three pos_embed subgraphs (~60-80 ONNX nodes each) are detected via pre-pass scanner and replaced with a single fused ggml_map_custom3 op. The CPU kernel computes 2D relative position bias directly: bias[b,hq,wq,hk,wk] = dot(x, W_h) + dot(x_transposed, W_w).
• Pre-pass scanner: detect_pos_embed_blocks() identifies contiguous node ranges with /pos_embed/ in output names, extracts W_h/W_w initializer shapes to determine H, W, C, validates F32 data type.
• Model count: 13/15 ONNX Model Zoo models now pass (was 12/15).

ONNX: pinned staging buffer for GPU input transfer

• When Vulkan GPU is available, a host-visible pinned memory buffer is allocated at model load time for ONNX input data. In onnx_ggml_run(), input data is copied into pinned memory before ggml_backend_tensor_set() — the Vulkan driver detects the pinned source pointer and performs direct DMA transfer to VRAM, bypassing the internal staging copy.
• Fallback: if ggml_backend_vk_host_buffer_type() returns NULL or buffer is too small, the standard staging path is used transparently.

Bug fixes

• onnx_device_info(): added NULL guards for ctx->graph and n_nodes == 0 edge cases that caused segfault when called on models before first inference run.

ggmlR 0.6.5

Bug fixes

• ggml_predict() with stochastic dropout: nn_build_graph() now receives training = FALSE during inference, so stochastic Bernoulli dropout is disabled at predict time. Previously, stochastic = TRUE dropout layers applied random masks during inference, degrading accuracy.
• ggml_fit() return value: the return value of ggml_fit() must be assigned back to model to obtain trained weights (model <- ggml_fit(...)). This is now clarified in all examples and documentation. Using history <- ggml_fit(...) without reassigning model leaves the model with untrained weights.
• ggml_evaluate() return value: now includes n_samples in addition to loss and accuracy. Metrics are computed on all samples without truncation (via ggml_predict() internally).

Examples

• inst/examples/titanic_classification.R — new end-to-end binary classification example on the Titanic dataset. Demonstrates feature engineering (Title, FamilySize, IsAlone), stratified train/val split, one-hot encoding, dropout regularization, and manual validation metrics (accuracy, precision, recall, F1, confusion matrix). Achieves ~82% val accuracy.

ONNX inference: dedicated weight buffer architecture

• Zero-overhead repeated inference: weights are loaded to GPU (or CPU) once via a dedicated weight_buf and never re-transferred between runs. Previous architecture reloaded all weights before every onnx_run() call — eliminated entirely.
• Separate ctx_weight / ctx contexts: weight tensors live in a permanent GPU buffer that the scheduler never aliases; compute tensors are managed by ggml_backend_sched independently.
• GPU speedups from eliminated weight reload (vs 0.6.3):
  • SuperResolution: 354 ms → 7 ms (48x)
  • BERT: 100 ms → 15 ms (7x)
  • Inception V3 Op18: 106 ms → 14 ms (7x)
  • Inception V3: 24 ms → 14 ms (1.7x)
  • EmotionFerPlus: 4.7 ms → 1.7 ms (2.8x)
  • BAT-ResNeXt: 14 ms → 9 ms (1.6x)
• onnx_device_info() — scheduler diagnostic: number of splits, GPU/CPU op counts, CPU-only op list.
• GPT-NeoX model now loads and runs successfully (was failing on shape propagation).
• Benchmark script (inst/examples/benchmark_onnx.R): proper VRAM cleanup between models via rm() + gc().

ggmlR 0.6.3

ONNX model import

• onnx_load(path, device, input_shapes) — load an ONNX model file, build a ggml computation graph, and allocate tensors on Vulkan GPU or CPU. Weights are loaded via memory-mapped file (zero-copy where possible).
• onnx_run(model, inputs) — run inference on a loaded ONNX model with named input data.
• onnx_inputs(model) — list expected input tensor names and shapes.
• onnx_summary(model) — return model metadata (IR version, opset, producer, ops used).
• print.onnx_model() — formatted summary of a loaded ONNX model.
• Built-in zero-dependency protobuf parser: no external libraries or Python required.
• input_shapes parameter for models with dynamic dimensions: specify fixed shapes at load time (e.g. input_shapes = list(image = c(1L, 3L, 224L, 224L))).
• 40+ supported ONNX ops: Add, Sub, Mul, Div, MatMul, Gemm, Conv (1D/2D), ConvTranspose (1D/2D), Relu, Sigmoid, Tanh, GELU, SiLU, LeakyRelu, Elu, Softmax, MaxPool, AveragePool, GlobalAveragePool, BatchNormalization, LayerNormalization, GroupNormalization, RMSNormalization, Reshape, Transpose, Concat, Flatten, Squeeze, Unsqueeze, Gather, Pad, Clip, Cast, Constant, ConstantOfShape, Shape, Expand, Slice, Split, Where, Erf, Pow, Sqrt, Exp, Log, Abs, Neg, Floor, Ceil, ReduceMean, ReduceSum, Resize/Upsample, Identity, Dropout.
• auto_pad attribute (SAME_UPPER, SAME_LOWER) supported for Conv and pooling ops.
• Numpy-style broadcast for binary ops (Add/Sub/Mul/Div): handles mismatched ranks and dimensions, with left-align, right-align, and greedy dim-matching strategies.
• Scalar Constant tensors (0-dimensional TensorProto) correctly handled.

Tested real-world ONNX models (13/15 from ONNX Model Zoo)

• mnist-8 — OK (12 nodes)
• squeezenet1.0-8 — OK (66 nodes: Conv, Relu, MaxPool, Concat, Dropout, GlobalAveragePool, Softmax)
• adv_inception_v3 Opset 17/18 — OK (215 nodes)
• super-resolution-10 — OK with input_shapes (Conv, Reshape, Transpose)
• bert Opset 17 — OK (533 nodes: MatMul, Add, LayerNorm, GELU/Erf, Softmax, Shape, Gather, Cast, Where, ConstantOfShape)
• emotion-ferplus-8 — OK (52 nodes: Conv, Relu, MaxPool, Reshape, Gemm, Constant)
• sageconv Opset 16 — OK (24 nodes: MatMul, Add, Mul, Sigmoid, ReduceSum)
• roberta-sequence-classification-9 — OK with input_shapes (1180 nodes)
• bat_resnext26ts Opset 18 — OK (570 nodes: Conv, BatchNorm, SiLU, Concat, Expand, Split)
• gptneox Opset 18 — OK with input_shapes (482 nodes: MatMul, LayerNorm, GELU, Softmax)
• xcit_tiny — OK (436 nodes: MatMul, LayerNorm, Softmax, Concat, Transpose)
• MaskRCNN-12-int8 — OK (937 nodes: QLinearConv, DequantizeLinear, Resize, Concat, Reshape)
• botnet26t_256 (Opset 16) — OK (RelPosBias2D fused custom op, 3 pos_embed blocks replaced)
• Remaining failures: cait_xs24_384 (batched matmul 3D+).

ggmlR 0.6.2

• Fixed Windows cleanup script that removed inst/lib/libggml.a, breaking static linking from dependent packages (e.g. llamaR).

ggmlR 0.6.1

• dp_train(make_model, data, loss_fn, forward_fn, target_fn, n_gpu, n_iter, lr, max_norm, verbose) — data-parallel training across multiple replicas. Weights are broadcast from replica 0 before the first step; gradients are averaged across replicas each iteration; weights are re-broadcast after each optimizer update. Returns list(params, loss_history, model).
• ag_mul and ag_sub now support CPU broadcast: [d×s] * [1×s] and [d×s] * [d×1] shapes work correctly with proper gradient reduction.
• ag_softmax_cross_entropy_loss accepts integer target vectors (0-based class indices) and converts them to one-hot automatically.
• ggml_sum_rows f16 on Vulkan: F16→F16 dispatch now supported natively (no CPU fallback).

ggmlR 0.6.0

Dynamic autograd engine (PyTorch-style training)

• ag_tensor() / ag_param() — environment-backed tensors with reference semantics; in-place optimizer updates visible to all references.
• with_grad_tape({ ... }) — enables the global gradient tape for the enclosed forward pass.
• backward(loss) — reverse-mode automatic differentiation; returns a gradient environment keyed by tensor id.
• Differentiable ops: ag_matmul, ag_add (with bias broadcast), ag_sub, ag_mul, ag_scale.
• Activations: ag_relu, ag_sigmoid, ag_tanh, ag_softmax.
• Reduction / math ops: ag_sum, ag_mean, ag_log, ag_exp, ag_pow, ag_clamp.
• Shape ops: ag_reshape, ag_transpose.
• Loss functions: ag_mse_loss, ag_cross_entropy_loss, ag_softmax_cross_entropy_loss (numerically-stable fused).
• optimizer_sgd() — SGD with optional momentum.
• optimizer_adam() — Adam with bias-corrected moment estimates.
• ag_linear() — Glorot-initialised dense layer (closure-based, returns $forward, $params()).
• ag_gradcheck() — central finite-difference gradient checker (like torch.autograd.gradcheck).

Layer objects (environment-based, train/eval modes)

• ag_sequential(...) — ordered layer container; collects all parameters for the optimizer.
• ag_dropout(rate) — inverted dropout; identity in eval mode.
• ag_batch_norm(num_features) — batch normalisation with running statistics and learnable γ/β.
• ag_embedding(vocab_size, dim) — token lookup with scatter-add backward.
• ag_train(model) / ag_eval(model) — switch all sub-layers between train and eval mode.

Training utilities

• ag_dataloader(x, y, batch_size, shuffle, col_major) — mini-batch iterator with shuffle and $epoch() helper.
• lr_scheduler_step(optimizer, step_size, gamma) — step-decay learning rate.
• lr_scheduler_cosine(optimizer, T_max, lr_min, restart) — cosine-annealing (with optional SGDR warm restarts).
• clip_grad_norm(params, grads, max_norm) — clips all gradients by global L2 norm in-place.

ggmlR 0.5.9

• ggml_layer_lstm() — LSTM recurrent layer (unrolled BPTT).
• ggml_layer_gru() — GRU recurrent layer (unrolled BPTT).
• ggml_layer_global_max_pooling_2d() — reduces [H,W,C] to [C] via max pooling.
• ggml_layer_global_average_pooling_2d() — reduces [H,W,C] to [C] via average pooling.
• ggml_save_model() — saves full model (architecture + weights) to RDS file.
• ggml_load_model() — restores a model saved with ggml_save_model().
• ggml_dense(), ggml_conv_2d(), ggml_conv_1d(), ggml_batch_norm(), ggml_embedding(), ggml_lstm(), ggml_gru() — layer object constructors returning a reusable ggml_layer object.
• ggml_apply(tensor, layer) — applies a ggml_layer object to a tensor node; shared weights by object identity.

ggmlR 0.5.7

• ggml_layer_dropout() — dropout with deterministic or stochastic (per-epoch Bernoulli mask) mode.
• ggml_layer_embedding() — token embedding lookup for integer inputs.
• ggml_input() gains dtype argument ("float32" or "int32").
• Multi-output support in ggml_model() and ggml_predict().

ggmlR 0.5.6

• ggml_input() — declare a symbolic input tensor node (Functional API).
• ggml_model() — assemble a ggml_functional_model from input/output nodes.
• ggml_layer_add() — element-wise addition of tensor nodes (residual connections).
• ggml_layer_concatenate() — concatenate tensor nodes along an axis.
• All ggml_layer_*() functions now accept a ggml_tensor_node as first argument (Functional API mode).
• ggml_compile(), ggml_fit(), ggml_evaluate(), ggml_predict() are now S3 generics with methods for ggml_functional_model.

ggmlR 0.5.5

• ggml_fit_opt() — low-level optimizer loop with callbacks and learning-rate control.
• ggml_callback_early_stopping() — stops training when a metric stagnates.
• ggml_schedule_step_decay() — step learning-rate decay.
• ggml_schedule_cosine_decay() — cosine learning-rate annealing.
• ggml_schedule_reduce_on_plateau() — reduces LR when metric stops improving.
• ggml_opt_init_for_fit(), ggml_opt_set_lr(), ggml_opt_get_lr() — learning-rate control without recreating the optimizer context.

ggmlR 0.5.4

• Vulkan GPU backend support on Windows via configure.win.
• Vulkan auto-detected at build time on Linux and Windows.

ggmlR 0.5.3

• ggml_layer_conv_1d() — 1D convolution layer.
• ggml_layer_batch_norm() — batch normalization layer.
• ggml_predict_classes() — argmax wrapper returning 1-based class indices.
• summary.ggml_sequential_model() — detailed model summary with parameter counts.
• ggml_fit() now returns model$history (class ggml_history) with print and plot methods.
• Sequential API: ggml_model_sequential(), ggml_layer_dense(), ggml_layer_conv_2d(), ggml_layer_max_pooling_2d(), ggml_layer_flatten(), ggml_compile(), ggml_fit(), ggml_evaluate(), ggml_predict(), ggml_save_weights(), ggml_load_weights().
• Vulkan GPU backend covering 90%+ of ML operations.

ggmlR 0.5.2

• ggml_timestep_embedding() — sinusoidal timestep embeddings.
• N-D tensor access: ggml_set_f32_nd(), ggml_get_f32_nd(), ggml_set_i32_nd(), ggml_get_i32_nd().
• Tensor utilities: ggml_tensor_nb(), ggml_tensor_num(), ggml_tensor_copy(), ggml_tensor_set_f32_scalar(), ggml_get_first_tensor(), ggml_get_next_tensor().

ggmlR 0.5.1

• Static library libggml.a exported for linking by dependent packages.
• gguf.cpp added for GGUF file format support.
• Headers exported via inst/include/ for LinkingTo.

ggmlR 0.5.0

• Full optimization/training API: ggml_opt_init(), ggml_opt_free(), ggml_opt_fit(), ggml_opt_epoch(), ggml_opt_eval().
• Dataset management: ggml_opt_dataset_init(), ggml_opt_dataset_data(), ggml_opt_dataset_labels(), ggml_opt_dataset_shuffle().
• Training results: ggml_opt_result_init(), ggml_opt_result_loss(), ggml_opt_result_accuracy(), ggml_opt_result_pred().
• Extended backend API: device management, registry, async operations, graph planning, buffer management (~50 new functions).
• Loss functions: MSE, cross-entropy. Optimizers: AdamW, SGD.

ggmlR 0.4.0

• Multi-GPU backend scheduler API.
• Vulkan GPU backend support.

ggmlR 0.2.0

• Initial release: R bindings for GGML tensor library.
• Core tensor operations, neural network ops, activation functions, quantization (Q4_0, Q4_1, Q8_0), OpenMP parallelization, computation graph API.

These binaries (installable software) and packages are in development.
They may not be fully stable and should be used with caution. We make no claims about them.