Edge case

Abstract: Autonomous vehicle (AV) technology is positioned to have a significant impact on various industries. Hence, artificial intelligence powered AVs and modern vehicles with advanced driver-assistance systems have been operated in street networks for real-life testing. As these tests become more frequent, accidents have been inevitable and there have been reported crashes. The data from these accidents are invaluable for generating edge case test scenarios and understanding accident-time behavior. In this paper, we use the existing AV accident data and identify the atomic blocks within each accident, which are modular and measurable scenario units. Our approach formulates each accident scenario using these atomic blocks and defines them in the Measurable Scenario Description Language (M-SDL). This approach produces modular scenario units with coverage analysis, provides a method to assist in the measurable analysis of accident-time AV behavior, identifies edge scenarios using AV assessment metrics.

Abstract: Safe autonomous driving may be one of the most difficult engineering challenges that any artificial intelligence system has been asked to do since the birth of AI over sixty years ago. The difficulty is not within the task itself, but rather in the extremely small margin of allowable error given the human life at stake and the extremely large number of edge cases that have to be accounted for. In other words, we task these systems to expect the unexpected with near 100% accuracy, which is a technical challenge for machine learning methods that to date have generally been better at memorizing the expected than predicting the unexpected. In fact, the process of efficiently and automatically discovering the edge cases of driving may be the key to solving this engineering challenge. In this work, we propose and evaluate a method for discovering edge cases by monitoring the disagreement between two monocular-vision-based automated steering systems. The first is a proprietary Tesla Autopilot system equipped in the first generation of Autopilot-capable vehicles. The second is a end-to-end neural network trained on a large-scale naturalistic dataset of 420 hours or 45 million frames of autonomous driving in Tesla vehicles.

Abstract: This work considers the robustness of uncertain consensus networks. The first set of results studies the stability properties of consensus networks with negative edge weights. We show that if either the negative weight edges form a cut in the graph, or any single negative edge weight has magnitude less than the inverse of the effective resistance between the two incident nodes, then the resulting network is unstable. These results are then applied to analyze the robustness properties of the consensus network with additive but bounded perturbations of the edge weights. It is shown that the small-gain condition is related again to cuts in the graph and effective resistance. For the single edge case, the small-gain condition is also shown to be exact. The results are then extended to consensus networks with non-linear couplings.

Abstract: Experts often use particular control flow structures to make their code easier to read and modify, such as using the logical operator AND to conjoin conditions rather than nesting separate if statements. Within Boolean expressions, experts take advantage of short-circuit evaluation by ordering their conditions to avoid errors (such as checking that an index is within the bounds of an array before examining the value at that index). How well do students understand these structures? We investigate students’ use and understanding of conjoined versus separate conditions within a larger assessment of 125 undergraduate students at the end of their second- and third-semester CS courses (in algorithms & data structures and introductory software engineering). The assessment asked students to: write code where an edge case error could be avoided with short-circuit evaluation, revise their code with nudges towards expert structure, and answer comprehension questions involving code tracing. When writing, students frequently forgot to check for a key edge case. When that case was included, the check was often separated in its own if-statement rather than conjoined with the other conditions. This could indicate a stylistic choice or a belief that the check had to be separated for functionality. Notably, students who included all necessary conditions rarely exhibited the error of ordering them incorrectly. However, with code comprehension, students demonstrated significant misunderstandings about the effects of condition ordering. Students were more accurate on comprehension tasks with nested ifs than conjoined conditions, and this effect was most pronounced when the ordering of the conditions would lead to errors. When conditions were conjoined in a single expression, only 35% of students recognized that checking a value at an index before checking that the index was in bounds would lead to an error. However, 54% of students recognized the problem when the conditions were separated into individual if-statements. This demonstrates a subtlety in code execution that intermediate students may not have mastered and emphasizes the challenges in assessing students’ understanding solely via the way they write code.