Fully Convolutional Search Heuristic Learning for Rapid Path Planners

Takuya Narihira; Yuka Ariki

REVIEW 4 major objections 5 minor 22 references

Fully Convolutional Search Heuristic Learning for Rapid Path Planners

T0 review · 4 major / 5 minor · reviewed 2026-08-14 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read A fully convolutional network trained on optimal A* paths can learn search heuristics that cut expanded vertices by one to two orders of magnitude in seven 2D grid-world environments.

desk verdict Solid incremental extension of learned heuristics with a real result, but sparse-supervision generalization is assumed rather than measured. read the letter →

arxiv 1908.03343 v1 pith:L4IVX7EG submitted 2019-08-09 cs.LG cs.AIcs.RO

Yuka Ariki , Takuya Narihira This is my paper · ORCID

classification cs.LGcs.AIcs.RO

keywords pathplanningsearchheuristiclearningfullyconvolutionalnetworkcost-to-gogreedyA*algorithmtemporaldifference2Dgridworldnavigation

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Path planners such as A* rely on heuristic functions to focus the search, but hand-designed heuristics often fail when environments contain local traps. This paper proposes learning the heuristic directly: a fully convolutional network takes an obstacle map and a goal position as input and outputs a heuristic map of estimated cost-to-go for every cell in a single forward pass. The learned heuristic is then used inside a greedy search. On seven 2D grid-world environments, this reduces the average number of expanded vertices by one to two orders of magnitude relative to the Euclidean heuristic (for example, from 37,814 to 351 on Shifting gaps), while keeping path lengths close to optimal. The most practical training variant learns only from paths found by A*, avoiding the expensive full-map backward Dijkstra computation.

What carries the argument

The central mechanism is a fully convolutional network with no fully connected layers, which maps an obstacle map, an obstacle-distance map, and a goal-distance map to an image of heuristic values, one estimated cost-to-go per grid cell, in a single forward pass. Because convolution is local, neighboring heuristic values tend to be spatially consistent, and because the network is fully convolutional, all vertices are handled simultaneously. Three training regimes are introduced: BD regresses to full cost-to-go values generated by backward Dijkstra; Sparse regresses only to cells along A* optimal paths using a masked squared-error loss; Sparse+TD adds an iterative Bellman-style value update, implemented as fixed convolution plus a minimum operation, to create denser training targets from the current prediction.

What would settle it

On held-out maps from the same environment types, compute the exact cost-to-go with backward Dijkstra for cells that are not on any A* training path and compare them to the Sparse-trained network's predictions; if those off-path errors are large, the path-only supervision is not generalizing and expansion counts should approach Euclidean levels. A second test is to generate maps with obstacle layouts and trap placements outside the seven training environment types; if expansion counts return to Euclidean-scale values, the learned speedup is specific to the training distribution rather than a transferable heuristic.

Watch

Extended reading notes

Core claim

The central claim is that hand-designed search heuristics can be replaced by learned convolutional heuristics. An environment with obstacles is treated as an image, and a fully convolutional network predicts a cost-to-go value for every graph vertex at once; a greedy planner using this heuristic map expands far fewer vertices than one using the Euclidean heuristic while producing near-optimal paths. The paper further claims that supervision from A* optimal paths alone (the Sparse method) is sufficient to train such heuristics, and that a temporal-difference variant can compensate for missing off-path supervision. In experiments, the learned heuristic reduces search cost from 37,814 to 351 expanded vertices on Shifting gaps, and total planning time from 6.10 ms for A* with Euclidean heuristic to 2.48 ms for greedy search with the learned heuristic, including CNN inference.

Load-bearing premise

The central assumption is that a network trained with cost-to-go labels only on cells along A* optimal paths will produce accurate heuristic values for every other cell in the map at test time, because the greedy planner depends on those off-path predictions to avoid expanding many cells.

Editorial extensions

If this is right

Using the learned heuristic in greedy search reduces average expanded vertices by one to two orders of magnitude on all seven tested environments, for example from 37,814 to 351 on Shifting gaps.
Because the Sparse variant needs only A* paths rather than full backward Dijkstra, training-data generation scales to larger maps and higher-dimensional planning problems.
Total planning time, including CNN inference, is lower than A* with the Euclidean heuristic on the tested hardware (2.48 ms versus 6.10 ms), indicating real-time feasibility.
Path quality stays close to optimal, for example 350 versus 311 on Shifting gaps, even though the greedy planner does not guarantee optimality; remaining jaggedness can be post-smoothed.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

If the learned heuristic generalizes beyond the seven training environment types to unseen obstacle layouts, the same single-shot convolutional architecture could replace hand-crafted heuristics in on-board robot planners, not just 2D grids.
The success of Sparse suggests a testable hypothesis: optimal-path demonstrations alone contain enough information to regress a globally useful cost-to-go function, which connects this method to imitation learning and could be checked by measuring off-path prediction error against backward Dijkstra.
The temporal-difference variant injects Bellman consistency into the learned heuristic; one could push further by training with full value-iteration rollouts or by using the learned heuristic to initialize bidirectional or anytime search, which the paper does not test.
A stress test on maps with traps placed differently from the training distribution would clarify whether the speedup comes from memorizing environment types or from a transferable notion of obstacles and goals.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Quick take: the paper does what it says, but the headline gain is smaller than the abstract implies, and the stats are thin.

The genuinely new bit is sparse target generation: training a fully convolutional network to regress a whole cost-to-go map using only A* path labels, then using that map as a heuristic for greedy search. That is a real step beyond Bhardwaj et al. 2017, which needed dense Dijkstra targets and DAgger. The experiments on the seven 2D grid worlds are consistent: learned heuristic cuts expanded vertices by one to two orders of magnitude versus Euclidean, with path quality close to optimal. The timing breakdown is honest: CNN inference 2.23ms plus 0.25ms planning, so end-to-end it is about 2.5x faster than A* Euclidean, not the dramatic gain the expansion numbers suggest.

The soft spots are real but manageable. The most important is exactly the one the stress-test flags: Sparse supervises only pixels on the A* path, and there is no direct measurement of accuracy on off-path cells. Whole-map MAE and end-to-end search cost are indirect evidence; the visualizations help, but a table with path-pixel vs off-path MAE would settle it. I don't think this is fatal—the CNN is fully convolutional with wide receptive fields, and training samples many random start/goal pairs per map, so generalization is plausible—but right now it is an assumption.

The other issues: Tables 1 and 2 report only means, with no error bars or significance tests. The phrase 'no significant difference' is asserted, not demonstrated. Sparse+TD, which was supposed to fix sparse supervision, underperforms Sparse on several environments and is dropped without explanation. That is a loose end. No code or data is released, and the evaluation uses fixed start/goal (0,0)/(201,201), consistent with prior work but limited.

Who this is for: people working on learned heuristics or learning-for-planning. It is a solid incremental contribution, not a paradigm shift. It deserves peer review rather than desk rejection; a good referee would ask for error bars, off-path accuracy, a discussion of why TD didn't help, and hopefully code.

Referee Report

4 major / 5 minor

Summary. The paper proposes learning search heuristics for grid-world path planning with fully convolutional neural networks. Given a binary obstacle map and a goal location, the network outputs a cost-to-go heuristic map over all vertices, and this map is used as the scoring function in a greedy best-first planner. Three training variants are introduced: dense regression to Backward Dijkstra cost-to-go values (BD), regression only to vertices on A* optimal paths (Sparse), and Sparse with additional temporal-difference Bellman backups from the network's own predictions (Sparse+TD). Experiments on seven 201x201 grid-world environment types from the Bhardwaj et al. dataset report the number of expanded vertices and path quality. The Sparse model reduces average expanded vertices by roughly one to two orders of magnitude relative to the Euclidean heuristic (e.g., Shifting gaps from 37,814 to 351 in Table 2), gives path quality close to optimal, and is faster end-to-end than A* with the Euclidean heuristic on the reported timing test. The paper also compares with SaIL and reports lower search costs for the learned convolutional heuristic. The presentation includes learning curves, path visualizations, and sample best/worst cases.

Significance. The central idea is simple but potentially useful: if a CNN can regress a usable cost-to-go field from cheap A* path labels, it removes the need for the dense Backward Dijkstra computation that dominates training-data generation in prior imitation-learning heuristics. The fully convolutional single-pass inference is a real advantage over per-state fully connected predictors such as SaIL, and the paper makes a concrete, falsifiable claim about large reduction in expanded vertices on seven benchmark maps. I credit the authors for reporting the Sparse+TD negative result instead of suppressing it, for comparing against an existing implementation on GitHub, and for including visualizations that show the jaggy-path limitation. At the same time, the reported evidence is preliminary: there are no variance or error bars, no code release, no explicit off-path accuracy measurement, and the test protocol uses a single start/goal pair. As a consequence, the strength of the main claim should be regarded as promising rather than established.

major comments (4)

[Section 3.3, Tables 1 and 2] All quantitative comparisons are made on means over 100 test maps, but the tables give no standard deviations, confidence intervals, or significance tests. The text uses "significant" (Section 3.3) and "no significant difference" (Section 3.3) without supporting statistics. Given that the central claim is an order-of-magnitude reduction, the effect is likely robust, but differences such as Mazes Sparse (403) vs Sparse+TD (941) and the small path-quality gaps need distributional evidence. Please report per-map distributions or error bars and, where comparisons are made, a significance test or effect size.
[Section 2.2, eq. (4) and Section 3.3] The Sparse model minimizes eq. (4) with M=1 only on A* path vertices, but the greedy planner queries the network at arbitrary successor vertices (eq. (3)). The paper offers no direct evaluation of off-path heuristic accuracy. Figure 3 reports only whole-map MAE and does not state the mask used for that MAE. This is a load-bearing generalization assumption: if the CNN has only learned to reconstruct values along one-dimensional paths, the reported reductions in expanded vertices may not transfer to different maps, different start/goal pairs, or to cells that the planner actually visits. I request an off-path accuracy analysis and a test with randomly sampled start/goal pairs.
[Section 3.1 and Table 2] The evaluation uses one fixed start/goal pair, (0,0) to (201,201), for every test map, whereas training samples random start/goal pairs. Consequently, the headline numbers in Table 2 only demonstrate performance for a single query configuration per map. A learned heuristic for planning should be evaluated over a distribution of start/goal pairs; without this, the claim that the method "significantly outperforms" is not yet generalized. This is a correctness-risk concern with a concrete remedy: repeat the evaluation over multiple start/goal pairs and report the spread.
[Section 3.3 and Table 1] The Sparse+TD variant was proposed specifically to compensate for sparse supervision, but Table 1 shows it is worse than Sparse in search cost on five of seven environments (e.g., Mazes 941 vs 403) and gives no consistent path-quality gain. The paper then drops it from the main comparison. The sentence "no significant difference is observed" is not supported by any statistical test, and no sensitivity analysis for lambda=0.001 or the three TD steps is provided. Either provide such analysis or explicitly frame Sparse+TD as an unsupported variant; as written, the contribution list overstates its role.

minor comments (5)

[Table 2] The multi-row header is difficult to parse; the grouping of planner and heuristic columns and the duplicated "SaIL" labels make it unclear which columns correspond to search cost versus path quality. Please reformat with clear column groups and a caption explaining the layout.
[Section 3.1] The map is described as 201x201 and the fixed evaluation goal as (201,201); if vertices are indexed 0 to 200, (201,201) is outside the grid. Please clarify the coordinate convention.
[Section 3.2] The training-time augmentation is described as random image translation producing 224x224 feature maps from 201x201 inputs; it should be stated whether this translation also shifts the goal coordinate and how the heuristic targets are transformed, since translation equivariance is not trivial for the distance-to-goal input channel.
[Section 3.3, timing paragraph] The timing comparison reports a single average for each method (e.g., 2.48 ms total for ours) with no repetitions or variance. Given that CNN inference runs on a GPU and the baselines are CPU-based, please state the measurement protocol and report error bars for the wall-clock comparison.
[Figure 4] The selection of "best" and "worst" cases is not defined by a quantitative criterion, which makes the visual comparison anecdotal. Please specify how these cases were chosen.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular dependency: the learned heuristic is a supervised regression to planner-generated cost-to-go values, and the headline search-cost comparison is evaluated independently against Euclidean and SaIL baselines.

full rationale

The paper's derivation chain is self-contained with respect to its central claim. The learned heuristic h(v, phi) is trained by minimizing the masked squared error in Eq. (4) against cost-to-go targets produced by Backward Dijkstra (BD) or A* (Sparse). These targets are defined by the graph and planner, not by the learned model. The evaluation then measures the number of expanded vertices when the learned heuristic is used in a greedy search (Eq. 3) on held-out test maps, comparing against Euclidean distance and the external SaIL method. The reported reduction in search cost is a contingent empirical result: even a perfect copy of the optimal cost-to-go would not logically force the observed search-cost numbers without running the planner. The Sparse+TD variant does bootstrap targets from its own predictions via Eq. (5), but it is not the headline method; the paper explicitly says 'We used Sparse in the subsequent experiments' and the main Table 2 reports Learned(Sparse). No load-bearing step relies on a self-citation: all cited algorithmic baselines (A*, Dijkstra, SaIL) are external, and the authors cite no prior work of their own as justification for the core approach. The skeptical concern that path-only supervision leaves off-path heuristic values unverified is a generalization risk, not a circularity: the model could fail to generalize, but that failure would not make the derivation equivalent to its inputs. Therefore the paper exhibits no significant circularity.

Assumptions & free parameters 2 free parameters · 4 assumptions · 0 invented entities

The central claim is supported by supervised regression to independently generated cost-to-go targets; no new physical entities, forces, or conserved quantities are introduced. The main philosophical load is carried by the representativeness of the benchmark dataset and the generalization from sparse path labels.

free parameters (2)

lambda (TD loss weight) = 0.001
Set in eq. (6) to balance the TD loss in Sparse+TD; no sensitivity analysis is reported.
TD iteration steps = 3
Chosen in Section 2.2 to compute the refined cost-to-go estimate in Sparse+TD; the paper does not study the effect of this count.

assumptions (4)

domain assumption The Bhardwaj et al. grid-world dataset is representative of path-planning environments with local traps.
All evaluation is performed on these seven environment types; no evidence is given for other maps.
domain assumption An 8-connected 201 by 201 grid with distance-based edge costs defines the planning problem class.
Stated in Section 3.1; the learned heuristics are only validated for this graph.
domain assumption Regression loss confined to A* path vertices is sufficient to train a full-map heuristic.
The Sparse method in Section 2.2 uses mask M=1 only along paths and must generalize to all cells at test time.
domain assumption Evaluation with start (0,0) and goal (201,201) is representative of performance for the random train-time pairs.
Fixed in Section 3.1 for comparability with Bhardwaj et al., creating a train/test distribution shift.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Fully Convolutional Search Heuristic Learning for Rapid Path Planners." pith.science (2026). https://pith.science/paper/L4IVX7EG

@misc{pith2026190803343,
  author       = {Pith},
  title        = {Pith review of: Fully Convolutional Search Heuristic Learning for Rapid Path Planners},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/L4IVX7EG}},
  note         = {Machine review of arXiv:1908.03343}
}

read the original abstract

Path-planning algorithms are an important part of a wide variety of robotic applications, such as mobile robot navigation and robot arm manipulation. However, in large search spaces in which local traps may exist, it remains challenging to reliably find a path while satisfying real-time constraints. Efforts to speed up the path search have led to the development of many practical path-planning algorithms. These algorithms often define a search heuristic to guide the search towards the goal. The heuristics should be carefully designed for each specific problem to ensure reliability in the various situations encountered in the problem. However, it is often difficult for humans to craft such robust heuristics, and the search performance often degrades under conditions that violate the heuristic assumption. Rather than manually designing the heuristics, in this work, we propose a learning approach to acquire these search heuristics. Our method represents the environment containing the obstacles as an image, and this image is fed into fully convolutional neural networks to produce a search heuristic image where every pixel represents a heuristic value (cost-to-go value to a goal) in the form of a vertex of a search graph. Training the heuristic is performed using previously collected planning results. Our preliminary experiments (2D grid world navigation experiments) demonstrate significant reduction in the search costs relative to a hand-designed heuristic.

Figures

Figures reproduced from arXiv: 1908.03343 by the authors.

**Figure 1.** First, we describe a search-based path planning al [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗

**Figure 2.** Convolutional neural networks (CNNs) are trained [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗

Figures from the paper (2 more)

**Figure 3.** Figure 3: Learning curves of prediction values and cost-to- [PITH_FULL_IMAGE:figures/full_fig_p007_3.png]

**Figure 4.** Figure 4: Visualization of the planned paths obtained from t [PITH_FULL_IMAGE:figures/full_fig_p009_4.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

22 extracted references · 17 canonical work pages

[1]

P. E. Hart, N. J. Nilsson, and B. Raphael. A formal basis for the heuristic determination of minimum cost paths. IEEE Transactions on Systems Science and Cybernetics, 4 0 (2): 0 100--107, July 1968

work page 1968
[2]

Learning motion planning assumptions

Anirudh Vemula, Sanjiban Choudhury, and Sebastian Scherer. Learning motion planning assumptions. Carnegie Mellon University Techinial Report, August 2014

work page 2014
[3]

Junior: The stanford entry in the urban challenge

Michael Montemerlo, Jan Becker, Suhrid Bhat, Hendrik Dahlkamp, Dmitri Dolgov, Scott Ettinger, Dirk Haehnel, Tim Hilden, Gabe Hoffmann, Burkhard Huhnke, Doug Johnston, Stefan Klumpp, Dirk Langer, Anthony Levandowski, Jesse Levinson, Julien Marcil, David Orenstein, Johannes Paefgen, Isaac Penny, Anna Petrovskaya, Mike Pflueger, Ganymed Stanek, David Stavens...

work page 2008
[4]

On curves of minimal length with a constraint on average curvature, and with prescribed initial and terminal positions and tangents

Lester E Dubins. On curves of minimal length with a constraint on average curvature, and with prescribed initial and terminal positions and tangents. American Journal of Mathematics, 79: 0 497--516, 1957

work page 1957
[5]

J. A. Reeds and L. A. Shepp. Optimal paths for a car that goes both forwards and backwards. Pacific Journal of Mathematics, 145 0 (2): 0 367--393, 1990

work page 1990
[6]

Learning deconvolution network for semantic segmentation

Hyeonwoo Noh, Seunghoon Hong, and Bohyung Han. Learning deconvolution network for semantic segmentation. In Proc . IEEE Int . Conf on Computer Vision (ICCV) , pages 1520--1528, 2015

work page 2015
[7]

Multi-Scale Context Aggregation by Dilated Convolutions

Fisher Yu and Vladlen Koltun. Multi-Scale Context Aggregation by Dilated Convolutions . In Proc . Int . Conf on Learning Representations (ICLR) , 2016

work page 2016
[8]

Show and tell: A neural image caption generator

Oriol Vinyals, Alexander Toshev, Samy Bengio, and Dumitru Erhan. Show and tell: A neural image caption generator. CoRR, abs/1411.4555, 2014

arXiv 2014

Show all 22 references

[9]

Shawn Hershey, Sourish Chaudhuri, Daniel P. W. Ellis, Jort F. Gemmeke, Aren Jansen, R. Channing Moore, Manoj Plakal, Devin Platt, Rif A. Saurous, Bryan Seybold, Malcolm Slaney, Ron J. Weiss, and Kevin W. Wilson. CNN architectures for large-scale audio classification. CoRR, abs...

2016 arXiv
[10]

Mastering the game of go without human knowledge

David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, Yutian Chen, Timothy Lillicrap, Fan Hui, Laurent Sifre, George van den Driessche, Thore Graepel, and Demis Hassabis. Masterin...

2017
[11]

Rusu, Joel Veness, Marc G

Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, ...

2015
[12]

Learning heuristic search via imitation

Mohak Bhardwaj, Sanjiban Choudhury, and Sebastian Scherer. Learning heuristic search via imitation. In Proc . 1st Annual Conf . on Robot Learning (CoRL) , pages 271--280, 2017

2017
[13]

Gordon, and J

St \' e phane Ross, Geoffrey J. Gordon, and J. Andrew Bagnell. No-regret reductions for imitation learning and structured prediction. CoRR, abs/1011.0686, 2010

2010 arXiv
[14]

Andrew Bagnell

St \' e phane Ross and J. Andrew Bagnell. Reinforcement and imitation learning via interactive no-regret learning. CoRR, abs/1406.5979, 2014

2014 arXiv
[15]

Watch this: Scalable cost-function learning for path planning in urban environments

Markus Wulfmeier, Dominic Zeng Wang, and Ingmar Posner. Watch this: Scalable cost-function learning for path planning in urban environments . In Proc . IEEE Int . Conf . on Intelligent Robots and Systems (IROS) , pages 2089--2095, 2016

2016
[16]

Maximum entropy deep inverse reinforcement learning

Markus Wulfmeier, Peter Ondruska, and Ingmar Posner. Maximum entropy deep inverse reinforcement learning. In Neural Information Processing Systems Conference, Deep Reinforcement Learning Workshop, 2015

2015
[17]

GOSELO: goal-directed obstacle and self-location map for robot navigation using reactive neural networks

Asako Kanezaki, Jirou Nitta, and Yoko Sasaki. GOSELO: goal-directed obstacle and self-location map for robot navigation using reactive neural networks. IEEE Robotics and Automation Letters , 3 0 (2): 0 696--703, 2018

2018
[18]

Wei Gao, David F. C. Hsu, Wee Sun Lee, Shengmei Shen, and Karthikk Subramanian. Intention-net: Integrating planning and deep learning for goal-directed autonomous navigation. In Proc . 1st Annual Conf . on Robot Learning (CoRL) , 2017

2017
[19]

Value iteration networks

Aviv Tamar, Yi Wu, Garrett Thomas, Sergey Levine, and Pieter Abbeel. Value iteration networks . In Proc . IJCAI International Joint Conference on Artificial Intelligence , 2017

2017
[20]

Cognitive mapping and planning for visual navigation

Saurabh Gupta, James Davidson, Sergey Levine, Rahul Sukthankar, and Jitendra Malik. Cognitive mapping and planning for visual navigation. In Proc . IEEE Conf . on Computer Vision and Pattern Recognition (CVPR) , pages 7272--7281, 2017

2017
[21]

Potential functions based sampling heuristic for optimal path planning

Ahmed Hussain Qureshi and Yasar Ayaz. Potential functions based sampling heuristic for optimal path planning. CoRR, abs/1704.00264, 2017

2017 arXiv
[22]

Kingma and Jimmy Ba

Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014

2014 arXiv

Pith tools

Reviewed August 14, 2026 · model on record in the stance chip above.

[1] [1]

P. E. Hart, N. J. Nilsson, and B. Raphael. A formal basis for the heuristic determination of minimum cost paths. IEEE Transactions on Systems Science and Cybernetics, 4 0 (2): 0 100--107, July 1968

work page 1968

[2] [2]

Learning motion planning assumptions

Anirudh Vemula, Sanjiban Choudhury, and Sebastian Scherer. Learning motion planning assumptions. Carnegie Mellon University Techinial Report, August 2014

work page 2014

[3] [3]

Junior: The stanford entry in the urban challenge

Michael Montemerlo, Jan Becker, Suhrid Bhat, Hendrik Dahlkamp, Dmitri Dolgov, Scott Ettinger, Dirk Haehnel, Tim Hilden, Gabe Hoffmann, Burkhard Huhnke, Doug Johnston, Stefan Klumpp, Dirk Langer, Anthony Levandowski, Jesse Levinson, Julien Marcil, David Orenstein, Johannes Paefgen, Isaac Penny, Anna Petrovskaya, Mike Pflueger, Ganymed Stanek, David Stavens...

work page 2008

[4] [4]

On curves of minimal length with a constraint on average curvature, and with prescribed initial and terminal positions and tangents

Lester E Dubins. On curves of minimal length with a constraint on average curvature, and with prescribed initial and terminal positions and tangents. American Journal of Mathematics, 79: 0 497--516, 1957

work page 1957

[5] [5]

J. A. Reeds and L. A. Shepp. Optimal paths for a car that goes both forwards and backwards. Pacific Journal of Mathematics, 145 0 (2): 0 367--393, 1990

work page 1990

[6] [6]

Learning deconvolution network for semantic segmentation

Hyeonwoo Noh, Seunghoon Hong, and Bohyung Han. Learning deconvolution network for semantic segmentation. In Proc . IEEE Int . Conf on Computer Vision (ICCV) , pages 1520--1528, 2015

work page 2015

[7] [7]

Multi-Scale Context Aggregation by Dilated Convolutions

Fisher Yu and Vladlen Koltun. Multi-Scale Context Aggregation by Dilated Convolutions . In Proc . Int . Conf on Learning Representations (ICLR) , 2016

work page 2016

[8] [8]

Show and tell: A neural image caption generator

Oriol Vinyals, Alexander Toshev, Samy Bengio, and Dumitru Erhan. Show and tell: A neural image caption generator. CoRR, abs/1411.4555, 2014

arXiv 2014