DeepGo: Multidomain Deep Learning Systems

• DeepGo refers to a set of deep learning frameworks applied to diverse domains including computer Go, directed greybox fuzzing, and ontology-aware protein function prediction.
• These systems replace traditional heuristics by integrating learned representations with domain-specific search methods, recurrent models, and structured constraints.
• Empirical evaluations show significant improvements in move prediction accuracy, fuzzing efficiency, and biological annotation precision across varied application areas.

DeepGo, and the closely related capitalization DeepGO, denotes several distinct deep-learning systems that emerged in different research domains rather than a single canonical method. In computer Go, the name is associated with policy networks, recurrent-convolutional move predictors, and search-guided systems for two-player and multiplayer play [(Maddison et al., 2014); (Wang et al., 2017); (Driss et al., 2024)]. In software testing, it denotes a predictive directed greybox fuzzer that learns path-transition dynamics and mutation policies (Lin et al., 29 Jul 2025). In computational biology, it denotes an ontology-aware classifier for protein function prediction from amino-acid sequence and cross-species interaction networks (Kulmanov et al., 2017). Across these usages, the common pattern is the replacement or augmentation of heuristic evaluation with learned representations, but the task formulations, architectures, and evaluation criteria are domain-specific.

1. Early DeepGo in 19×19 computer Go

One early line of work cast Go move selection as supervised prediction of expert moves from board states. In "Teaching Deep Convolutional Neural Networks to Play Go" (Clark et al., 2014), the task was defined on a 19×19 board with a softmax over legal intersections, trained by cross-entropy on expert moves. The strongest model used eight convolutional layers followed by a fully connected output layer, with zero-padding to preserve spatial resolution, stride 1, no pooling, and ReLU activations. The input representation combined board occupancy, simple-ko constraints, liberties encoding, and an explicit edge channel. A central design choice was dihedral symmetry weight tying: filter and output-layer parameters were constrained so that reflecting or rotating the board produced correspondingly reflected or rotated outputs. On move prediction, the full-scale network achieved 41.06% top-1 accuracy on GoGoD and 44.37% on KGS; in direct play without Monte Carlo Tree Search, KGS-trained and GoGoD-trained networks consistently defeated GNU Go and won some games against Fuego (Clark et al., 2014).

A second and more explicitly policy-centric formulation appeared in "Move Evaluation in Go Using Deep Convolutional Neural Networks" (Maddison et al., 2014). There, DeepGo was a 12-layer fully convolutional CNN that modeled a player-conditioned policy $\pi(a \mid s,\mathrm{player})$ over the 361 intersections of a 19×19 board, with two separate 19×19 logit planes and softmaxes for Black-to-move and White-to-move. The input was a 36-plane stack encoding stone color, liberties, liberties after move, legality, turns-since-played, capture size, a ladder feature, and a global KGS rank indicator. Training used 29.4 million state–action pairs from 160,000 KGS games, with the objective

$$p(a \mid s,\mathrm{player}) = \frac{\exp(z_a)}{\sum_b \exp(z_b)}, \qquad L = -\sum_i \log p(a_i \mid s_i,\mathrm{player}_i).$$

The strongest 12-layer, 128-filter model reached 55.2% top-1 expert move prediction on held-out test positions, with the correct move among the top 10 predictions 94% of the time. When played greedily without search, it achieved a 97.2% win rate against GnuGo 3.8 at level 10 and matched the performance of strong MCTS systems operating at the scale of millions of simulated positions per move; it was also compared to a 6-dan human scorer who achieved 52% ± 5.8% on the same test set (Maddison et al., 2014).

2. Recurrent refinement and long-term local evaluation in Go

A later non-MCTS-centric Go system combined supervised move prediction with a learned local evaluator. In "Beyond Monte Carlo Tree Search: Playing Go with Deep Alternative Neural Network and Long-Term Evaluation" (Wang et al., 2017), the move predictor was a Deep Alternative Neural Network (DANN), built from six alternative layers in which each feed-forward convolution was followed by a recurrent convolutional refinement repeated for $T$ steps with shared recurrent weights. The recurrence was defined as

$$u_{ij}^{xyz}(t) = u_{ij}^{xyz}(0) + f(w_{ij}^r u_{ij}^{xyz}(t-1)) + b_{ij},$$

with $u_{ij}^{xyz}(0)$ produced by feed-forward convolution. The network consumed 41 feature planes, including ladder capture, ladder escape, sensibleness, legality, player color, stone-color planes, current liberties, liberties after move, turns-since, capture size, and self-atari size. Its architecture used 3×3 feed-forward and recurrent kernels, ReLU, local response normalization, 2×2 max pooling, two fully connected layers of size 1024, and a softmax over board points with illegal moves masked to 0. Increasing the recurrent depth improved performance; for the 6AL_2FC configuration, top-1 accuracy rose from 46.4%/47.2% at $T=2$ to 57.7%/53.8% at $T=5$ on GoGoD/PGD.

The same system added a Long-Term Evaluation (LTE) module, an RNN-based local simulator that evaluated promising candidate moves by sequentially attending to local regions and accumulating an undiscounted cumulative reward

$R = \sum_{t=1}^{T} r_t.$

Candidates were scored by the product $\mathcal{S} = p \times \mathbb{E}[R]$, where $p$ was the DANN softmax probability. With LTE, top-1 accuracy reached 61% on GoGoD and 56% on PGD. In match play, the reported 6-layer DANN + LTE system achieved 100% ± 0.0 against GnuGo, 72.5% ± 1.8 against MoGo 10k, 83.1% ± 1.4 against Pachi 10k, 65.3% ± 1.6 against Pachi 100k, 82.6% ± 1.2 against Fuego 10k, and 76.5% ± 1.6 against Fuego 100k (Wang et al., 2017).

3. Multiplayer DeepGo and general-sum search

A distinct contemporary usage of the name appears in "Deep Reinforcement Learning for 5×5 Multiplayer Go" (Driss et al., 2024), which extends AlphaZero-style search and self-play to a three-player, general-sum 5×5 Go variant with Black, White, and Red stones. The game used Chinese scoring without komi, and the experiments compared two objectives, “win” and “maximize score”; because multiplayer Go can exhibit “queer games” involving coalitions and kingmaking, maximizing score was selected for the main experiments. The action space contained the 25 board intersections, with pass removed except when no moves were possible or only eye-filling moves remained. The state representation was a 6-channel 5×5 tensor with three occupancy planes and three player-to-move planes.

The AlphaZero-style system retained MCTS with PUCT,

$$p(a \mid s,\mathrm{player}) = \frac{\exp(z_a)}{\sum_b \exp(z_b)}, \qquad L = -\sum_i \log p(a_i \mid s_i,\mathrm{player}_i).$$0

with $$p(a \mid s,\mathrm{player}) = \frac{\exp(z_a)}{\sum_b \exp(z_b)}, \qquad L = -\sum_i \log p(a_i \mid s_i,\mathrm{player}_i).$$1 and 180 simulations per move. The network comprised 8 residual blocks with 128 filters and 3×3 convolutions, a policy head producing a 25-way categorical distribution, and a value head that predicted three categorical score distributions, one per player, over scores 0–25. Self-play generated $$p(a \mid s,\mathrm{player}) = \frac{\exp(z_a)}{\sum_b \exp(z_b)}, \qquad L = -\sum_i \log p(a_i \mid s_i,\mathrm{player}_i).$$2 triples, and the loss summed cross-entropy terms for the three value heads, the policy head, and an $$p(a \mid s,\mathrm{player}) = \frac{\exp(z_a)}{\sum_b \exp(z_b)}, \qquad L = -\sum_i \log p(a_i \mid s_i,\mathrm{player}_i).$$3 regularizer. A warm-start mechanism mixed in UCT-controlled players with probability

$$p(a \mid s,\mathrm{player}) = \frac{\exp(z_a)}{\sum_b \exp(z_b)}, \qquad L = -\sum_i \log p(a_i \mid s_i,\mathrm{player}_i).$$4

with $$p(a \mid s,\mathrm{player}) = \frac{\exp(z_a)}{\sum_b \exp(z_b)}, \qquad L = -\sum_i \log p(a_i \mid s_i,\mathrm{player}_i).$$5.

The paper also evaluated Descent, a value-only best-first Unbounded Minimax method guided by a neural value network. Both approaches improved over a UCT baseline. Over 500 games, baseline UCT yielded average points of 11.5 ± 1.0 for Black, 7.1 ± 0.9 for White, and 6.3 ± 0.9 for Red. Across 120 training hours, AlphaZero improved to approximately Black 16, White 10, Red 11 against UCT opponents, while Descent converged around Black 12, White 12, Red 11. In head-to-head evaluation as Black, AlphaZero scored 16.2 ± 0.3 against White+Red UCT, 13.3 ± 0.4 against White+Red AlphaZero, and 11.0 ± 0.2 against White+Red Descent; Descent as Black scored 12.7 ± 0.5, 12.1 ± 0.6, and 11.9 ± 0.3 in the corresponding matchups (Driss et al., 2024).

4. DeepGo in predictive directed greybox fuzzing

Outside games, "DeepGo" designates a directed greybox fuzzing system in "DeepGo: Predictive Directed Greybox Fuzzing" (Lin et al., 29 Jul 2025). The target problem is directed greybox fuzzing (DGF), where fuzzing effort is concentrated on predefined target sites such as suspected vulnerabilities or recently patched code locations. The paper argues that conventional DGF methods optimize heuristic distance-based fitness metrics but lack foresight about hard-to-execute future paths. DeepGo addresses this by modeling fuzzing as a sequence of path transitions induced by mutations.

The system contains four coupled components operating in cycles of about 20 minutes. The Path Transition Model (PTM) treats states as execution paths represented by AFL trace_bits, actions as mutation locations, and rewards as differences in a seed-value function

$$p(a \mid s,\mathrm{player}) = \frac{\exp(z_a)}{\sum_b \exp(z_b)}, \qquad L = -\sum_i \log p(a_i \mid s_i,\mathrm{player}_i).$$6

where the factors are BB-distance to target, branch inversion difficulty, execution speed, and favoredness. Transition reward is

$$p(a \mid s,\mathrm{player}) = \frac{\exp(z_a)}{\sum_b \exp(z_b)}, \qquad L = -\sum_i \log p(a_i \mid s_i,\mathrm{player}_i).$$7

and the expected sequence reward follows a Bellman-style recursion

$$p(a \mid s,\mathrm{player}) = \frac{\exp(z_a)}{\sum_b \exp(z_b)}, \qquad L = -\sum_i \log p(a_i \mid s_i,\mathrm{player}_i).$$8

The Virtual Ensemble Environment (VEE) predicts unseen path transitions and rewards using an ensemble of six identical 5-layer fully connected DNNs. Paths are embedded into 20-dimensional continuous vectors by Coupled Data Embedding, actions are encoded as normalized mutation offsets, and outputs are Gaussian predictive distributions over next path and reward. The Reinforcement Learning for Fuzzing (RLF) module uses Soft Actor-Critic with three-layer fully connected actor and critic networks and learning rates of 0.005, combining historical and VEE-predicted transitions. Finally, Fuzzing Optimization translates the policy into a 27-dimensional action group spanning seed selection, seed energy, havoc rounds, mutator probabilities, and location-type probabilities, optimized by Multi-elements PSO.

Empirically, the system was evaluated on 25 programs and 100 target sites, with 24-hour runs and five repetitions per configuration. On a UniBench subset of 80 target sites, DeepGo reached 73/80 targets, compared with AFLGo 22/80, BEACON 11/80, WindRanger 19/80, and ParmeSan 9/80. Mean time-to-reach speedups were 3.23× over AFLGo, 1.72× over BEACON, 1.81× over WindRanger, and 4.83× over ParmeSan, with all Mann-Whitney U $$p(a \mid s,\mathrm{player}) = \frac{\exp(z_a)}{\sum_b \exp(z_b)}, \qquad L = -\sum_i \log p(a_i \mid s_i,\mathrm{player}_i).$$9-values below 0.05. On 20 CVEs in the AFLGo testsuite, DeepGo exposed 19 vulnerabilities versus 14, 13, 16, and 14 for AFLGo, BEACON, WindRanger, and ParmeSan, respectively. Reported predictive accuracy for the VEE was 92.57% for transition probabilities and 91.10% for rewards, while ablations without VEE or without RLF+FO showed substantial degradation (Lin et al., 29 Jul 2025).

5. DeepGO in ontology-aware protein function prediction

In computational biology, "DeepGO" refers to a hierarchical, multi-modal classifier for protein function prediction. In "DeepGO: Predicting protein functions from sequence and interactions using a deep ontology-aware classifier" (Kulmanov et al., 2017), the task is framed as a large-scale, multi-class, multi-label prediction problem over the Gene Ontology (GO), which in the reported 2016 release contained 44,683 classes, of which 28,647 were Biological Process, 10,161 Molecular Function, and 3,907 Cellular Component. Because GO is a directed acyclic graph and proteins can have multiple functions, the model explicitly wires ontology structure into the classifier.

The sequence branch represents each protein by 1,000 amino-acid trigram indices, embedded into 128-dimensional vectors to form a 1000×128 matrix. A 1D convolutional layer with 32 filters and kernel size 128, followed by temporal max-pooling with pool length 64 and stride 32, produces an 832-dimensional sequence feature vector. This is concatenated with a 256-dimensional protein-protein interaction embedding derived from a cross-species knowledge graph built from STRING interactions and eggNOG orthology, yielding a 1,088-dimensional feature vector. For each selected GO term, the classifier builds a per-term subnetwork with a 256-unit ReLU dense layer that receives the protein features and the first-layer outputs of parent terms, followed by a 1-unit sigmoid classifier. For internal GO nodes, a merge layer outputs the maximum of the node’s own classifier and all children’s classifier outputs, enforcing ancestor scores to be at least as large as descendant scores. Training used multi-output binary cross-entropy with Rmsprop at learning rate 0.01, Glorot uniform initialization, dropout, and mini-batches of size 128.

The dataset contained 60,710 proteins after evidence and sequence filtering, with annotations propagated to ancestors. Three separate namespace-specific models were trained on selected frequent terms: 932 BP terms with at least 250 annotations, 589 MF terms with at least 50 annotations, and 436 CC terms with at least 50 annotations. In CAFA-style protein-centric evaluation over all annotations, DeepGO achieved $T$0 for BP, 0.46 for MF, and 0.63 for CC, compared with BLAST baselines of 0.31, 0.37, and 0.36. On selected terms only, DeepGO achieved 0.40 for BP, 0.50 for MF, and 0.64 for CC. The strongest relative improvement was reported for cellular component prediction, and the paper emphasized that adding PPI embeddings improved performance relative to the sequence-only variant DeepGOSeq in almost all classes and namespaces (Kulmanov et al., 2017).

6. Conceptual commonalities, distinctions, and recurring misconceptions

The reused name can be misleading. A common misconception is that DeepGo denotes a single Go engine in the style of AlphaGo. The literature instead contains multiple, technically distinct systems. The original 19×19 DeepGo formulations were primarily supervised policy networks trained from professional games; one emphasized symmetry-preserving DCNNs with legal masking, and another used a 12-layer fully convolutional policy with rule-aligned feature planes and no search at play time [(Clark et al., 2014); (Maddison et al., 2014)]. By contrast, the multiplayer 5×5 system was a self-play reinforcement-learning framework with MCTS/PUCT or best-first Unbounded Minimax, vector-valued score prediction, and a general-sum objective (Driss et al., 2024).

A second misconception is that the term is exclusive to board games. In program analysis, DeepGo is a directed fuzzer whose state is an execution path, whose action is a mutation choice, and whose objective is time-to-reach or time-to-expose a target site (Lin et al., 29 Jul 2025). In bioinformatics, DeepGO is a multi-label ontology classifier over protein functions and cellular locations, integrating sequence encodings with cross-species interaction embeddings and GO hierarchy constraints (Kulmanov et al., 2017). These systems are unrelated at the application level.

A plausible unifying interpretation is methodological rather than semantic. In each case, a learned model is coupled to explicit domain structure: legality planes, player-conditioned softmaxes, and search in Go; path-transition rewards, uncertainty-aware ensembles, and action-group optimization in fuzzing; ontology wiring and ancestor-consistent max merges in protein annotation. A further plausible implication is that later deep-learning Go systems outside the nominal DeepGo label, such as KataGo, made this pattern more explicit by combining neural policy/value heads, global pooling, auxiliary ownership and score targets, and improved MCTS to obtain roughly a 50× reduction in computation relative to AlphaZero-like runs (Wu, 2019). The name therefore indexes a recurring research strategy—deep representation learning coupled to structured decision constraints—rather than a single stable architecture or benchmark tradition.