sisl/autonomousriskframework.jl

Framework for autonomous vehicle risk assessment

Autonomous Vehicle Risk Assessment Framework

@techreport{moss2021autonomous,
  title={{Autonomous Vehicle Risk Assessment}},
  author={Robert J. Moss and Shubh Gupta and Robert Dyro and Karen Leung and Mykel J. Kochenderfer and Grace X. Gao and Marco Pavone and Edward Schmerling and Anthony Corso and Regina Madigan and Matei Stroila and Tim Gibson},
  institution={Stanford Center for AI Safety, Stanford University},
  year={2021}
}

Installation

Note: Julia v1.5+ is recommended for AutomotiveSimulator and POMDPStressTesting.

julia install.jl

Example

using RiskSimulator

system = IntelligentDriverModel()
scenario = get_scenario(MERGING)
planner = setup_ast(sut=system, scenario=scenario)

search!(planner)

fail_metrics = failure_metrics(planner)
α = 0.2 # risk tolerance
risk_metrics = metrics(planner, α)
risk = overall_area(planner, α=α)

CARLA experiment

See adversarial CARLA environment instructions here.

using AVExperiments

config = ExperimentConfig(
    seed=0xC0FFEE,
    agent=WorldOnRails,
    N=100,
    dir="results_wor",
    use_tree_is=true,
    leaf_noise=true,
    resume=false,
)

results = run_carla_experiment(config)

Related packages

• Adaptive stress testing:
  • https://github.com/sisl/POMDPStressTesting.jl
• Signal temporal logic computation graphs:
  • https://github.com/StanfordASL/stlcg
• Automotive simulator:
  • https://github.com/sisl/AutomotiveSimulator.jl (note AutomotiveDrivingModels.jl is deprecated)
  • Driving visualizations:
    • https://github.com/sisl/AutomotiveVisualization.jl (note AutoViz.jl is deprecated)
• Adversarial driving:
  • https://github.com/sisl/AdversarialDriving.jl
• Interpretability for validation:
  • https://github.com/sisl/InterpretableValidation.jl
  • Defining expression rules (for STL):
    • https://github.com/sisl/ExprRules.jl
• POMDPs framework:
  • https://github.com/JuliaPOMDP/POMDPs.jl

Publications

• See PUBLICATIONS.md

CARLA Installation

• See CARLAIntegration.

Code style

• See: https://github.com/invenia/BlueStyle

Known issues

INTEL MKL ERROR: Library not loaded: @rpath/libiomp5.dylib

This error was observed on MacOS and appears to be related to Conda. One solution that worked was to run

using Conda
Conda.rm("mkl")
Conda.add("nomkl")

See JuliaPy/PyPlot.jl#315 for relevant discussions.

Python version conflicts

Some versions of Python e.g., 3.9 are incompatible with the framework as they do not support packages such as pytorch that are needed. It is possible to switch to a working version of Python as follows:

using Conda
Conda.add("python=3.7.5")

However, note that if you were using an incompatible of Python before, you might have installed Python packages of versions that can conflict with the new compatible version of Python as the packages remain under the Conda directory. You may see error messages like the following if this is the case:

Package enum34 conflicts for:
pyopenssl -> cryptography[version='>=2.8'] -> enum34
cryptography -> enum34
brotlipy -> enum34
urllib3 -> brotlipy[version='>=0.6.0'] -> enum34
pyqt -> enum34

If so, you may need to remove the Conda directory to remove the packages and resintall them after setting Conda to use a correct version of Python i.e.,

rm -R ~/.julia/conda/  # Make sure this is okay to do in your case

then,

using Conda
Conda.add("python=3.7.5")
using RiskSimulator

Contacts

• Stanford Intelligent Systems Laboratory (SISL)
  • Robert Moss: mossr
  • Kyu-Young Kim: kykim0
• Navigation and Autonomous Vehicles Laboratory (NAV Lab)
  • Shubh Gupta: shubhg1996
• Stanford Autonomous Systems Laboratory (ASL)
  • Karen Leung: karenl7
  • Robert Dyro: rdyro

autonomousriskframework.jl's Issues

Installing in general Julia environment.

From my experience, the julia install.jl script installs all packages in the standard julia environment. Is this an intentional design choice, or did I do something wrong during the installation?

Missing SpAutoDiff from master

I get the following error when trying to run dev RiskSimulator.jl in julia package manager:

Resolving package versions... 
ERROR: Unsatisfiable requirements detected for package SpAutoDiff 
[2746dd70]:
 SpAutoDiff [2746dd70] log:      
 ├─SpAutoDiff [2746dd70] has no known versions!
 └─restricted to versions * by RiskSimulator [d80ce8e1] — no versions left
   └─RiskSimulator [d80ce8e1] log:
     ├─possible versions are: 0.1.0 or uninstalled
     └─RiskSimulator [d80ce8e1] is fixed to version 0.1.0

`julia install.jl` results in an error

Error Message

AutonomousRiskFramework.jl$ julia install.jl
     Cloning git-repo `https://github.com/sisl/AdversarialDriving.jl`
Path `/home/luttkule/.julia/dev/AdversarialDriving` exists and looks like the correct repo. Using existing path.
     Cloning git-repo `https://github.com/sisl/Vec.jl`
Path `/home/luttkule/.julia/dev/Vec` exists and looks like the correct repo. Using existing path.
     Cloning git-repo `https://github.com/shubhg1996/ImportanceWeightedRiskMetrics.jl`
Path `/home/luttkule/.julia/dev/ImportanceWeightedRiskMetrics` exists and looks like the correct repo. Using existing path.
     Cloning git-repo `https://github.com/shubhg1996/TreeImportanceSampling.jl`
Path `/home/luttkule/.julia/dev/TreeImportanceSampling` exists and looks like the correct repo. Using existing path.
     Cloning git-repo `https://github.com/ancorso/POMDPGym.jl`
Path `/home/luttkule/.julia/dev/POMDPGym` exists and looks like the correct repo. Using existing path.
     Cloning git-repo `https://github.com/ancorso/Crux.jl`
Path `/home/luttkule/.julia/dev/Crux` exists and looks like the correct repo. Using existing path.
   Resolving package versions...
ERROR: LoadError: Unsatisfiable requirements detected for package SpAutoDiff [2746dd70]:
 SpAutoDiff [2746dd70] log:
 ├─SpAutoDiff [2746dd70] has no known versions!
 └─restricted to versions * by AutonomousRiskFramework [f30adb48] — no versions left
   └─AutonomousRiskFramework [f30adb48] log:
     ├─possible versions are: 0.1.0 or uninstalled
     └─AutonomousRiskFramework [f30adb48] is fixed to version 0.1.0
Stacktrace:
  [1] check_constraints(graph::Pkg.Resolve.Graph)
    @ Pkg.Resolve /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.6/Pkg/src/Resolve/graphtype.jl:978
  [2] Pkg.Resolve.Graph(versions::Dict{Base.UUID, Set{VersionNumber}}, deps::Dict{Base.UUID, Dict{VersionNumber, Dict{String, Base.UUID}}}, compat::Dict{Base.UUID, Dict{VersionNumber, Dict{String, Pkg.Types.VersionSpec}}}, uuid_to_name::Dict{Base.UUID, String}, reqs::Dict{Base.UUID, Pkg.Types.VersionSpec}, fixed::Dict{Base.UUID, Pkg.Resolve.Fixed}, verbose::Bool, julia_version::VersionNumber)
    @ Pkg.Resolve /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.6/Pkg/src/Resolve/graphtype.jl:371
  [3] deps_graph(ctx::Pkg.Types.Context, uuid_to_name::Dict{Base.UUID, String}, reqs::Dict{Base.UUID, Pkg.Types.VersionSpec}, fixed::Dict{Base.UUID, Pkg.Resolve.Fixed})
    @ Pkg.Operations /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.6/Pkg/src/Operations.jl:537
  [4] resolve_versions!(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.PackageSpec})
    @ Pkg.Operations /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.6/Pkg/src/Operations.jl:407
  [5] targeted_resolve(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.PackageSpec}, preserve::Pkg.Types.PreserveLevel)
    @ Pkg.Operations /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.6/Pkg/src/Operations.jl:1215
  [6] tiered_resolve(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.PackageSpec})
    @ Pkg.Operations /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.6/Pkg/src/Operations.jl:1201
  [7] _resolve
    @ /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.6/Pkg/src/Operations.jl:1221 [inlined]
  [8] develop(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.PackageSpec}, new_git::Vector{Base.UUID}; preserve::Pkg.Types.PreserveLevel, platform::Base.BinaryPlatforms.Platform)
    @ Pkg.Operations /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.6/Pkg/src/Operations.jl:1258
  [9] develop(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.PackageSpec}; shared::Bool, preserve::Pkg.Types.PreserveLevel, platform::Base.BinaryPlatforms.Platform, kwargs::Base.Iterators.Pairs{Symbol, Base.TTY, Tuple{Symbol}, NamedTuple{(:io,), Tuple{Base.TTY}}})
    @ Pkg.API /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.6/Pkg/src/API.jl:149
 [10] develop(pkgs::Vector{Pkg.Types.PackageSpec}; io::Base.TTY, kwargs::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ Pkg.API /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.6/Pkg/src/API.jl:80
 [11] develop(pkgs::Vector{Pkg.Types.PackageSpec})
    @ Pkg.API /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.6/Pkg/src/API.jl:78
 [12] top-level scope
    @ /media/luttkule/HDD/git/AutonomousRiskFramework.jl/install.jl:40
in expression starting at /media/luttkule/HDD/git/AutonomousRiskFramework.jl/install.jl:40

MPCDriver not defined

using the example resulted in the following error:

julia> using RiskSimulator

julia> system = IntelligentDriverModel()
IntelligentDriverModel
  a: Float64 NaN
  σ: Float64 NaN
  k_spd: Float64 1.0
  δ: Float64 4.0
  T: Float64 1.5
  v_des: Float64 29.0
  s_min: Float64 5.0
  a_max: Float64 3.0
  d_cmf: Float64 2.0
  d_max: Float64 9.0


julia> scenario = get_scenario(MERGING)
Scenario
  roadway: AutomotiveSimulator.Roadway{Float64}
  sut: Agent
  adversary: Agent
  disturbances: Array{AdversarialDriving.Disturbance}((2,))


julia> planner = setup_ast(sut=system, scenario=scenario)
[ Info: Training observation model.
ERROR: UndefVarError: MPCDriver not defined
Stacktrace:
  [1] step_scene(mdp::AdversarialDriving.AdversarialDrivingMDP, s::AutomotiveSimulator.EntityScene{AdversarialDriving.BlinkerState, AutomotiveSimulator.VehicleDef, Int64}, actions::Vector{AdversarialDriving.Disturbance}, rng::Random._GLOBAL_RNG)
    @ RiskSimulator /media/luttkule/HDD/git/AutonomousRiskFramework.jl/RiskSimulator.jl/src/scenario.jl:47
  [2] gen(mdp::AdversarialDriving.AdversarialDrivingMDP, s::AutomotiveSimulator.EntityScene{AdversarialDriving.BlinkerState, AutomotiveSimulator.VehicleDef, Int64}, a::Vector{AdversarialDriving.Disturbance}, rng::Random._GLOBAL_RNG)
    @ AdversarialDriving ~/.julia/dev/AdversarialDriving/src/mdp.jl:83
  [3] macro expansion
    @ ~/.julia/packages/POMDPs/85BFM/src/gen_impl.jl:23 [inlined]
  [4] genout
    @ ~/.julia/packages/POMDPs/85BFM/src/gen_impl.jl:19 [inlined]
  [5] #121#f
    @ ~/.julia/packages/POMDPs/85BFM/src/generative.jl:65 [inlined]
  [6] iterate(it::WARNING: both POMDPs and AutomotiveSimulator export "simulate"; uses of it in module RiskSimulator must be qualified
POMDPSimulators.MDPSimIterator{(:s, :a, :sp, :r, :info, :t, :action_info), AdversarialDriving.AdversarialDrivingMDP, POMDPPolicies.FunctionPolicy{RiskSimulator.var"#85#86"{Vector{AdversarialDriving.Disturbance}}}, Random._GLOBAL_RNG, AutomotiveSimulator.EntityScene{AdversarialDriving.BlinkerState, AutomotiveSimulator.VehicleDef, Int64}}, is::Tuple{Int64, AutomotiveSimulator.EntityScene{AdversarialDriving.BlinkerState, AutomotiveSimulator.VehicleDef, Int64}})
    @ POMDPSimulators ~/.julia/packages/POMDPSimulators/zxTz3/src/stepthrough.jl:52
  [7] iterate
    @ ~/.julia/packages/POMDPSimulators/zxTz3/src/stepthrough.jl:46 [inlined]
  [8] _collect(cont::UnitRange{Int64}, itr::POMDPSimulators.MDPSimIterator{(:s, :a, :sp, :r, :info, :t, :action_info), AdversarialDriving.AdversarialDrivingMDP, POMDPPolicies.FunctionPolicy{RiskSimulator.var"#85#86"{Vector{AdversarialDriving.Disturbance}}}, Random._GLOBAL_RNG, AutomotiveSimulator.EntityScene{AdversarialDriving.BlinkerState, AutomotiveSimulator.VehicleDef, Int64}}, #unused#::Base.HasEltype, isz::Base.SizeUnknown)
    @ Base ./array.jl:613
  [9] collect
    @ ./array.jl:602 [inlined]
 [10] collect_history(it::POMDPSimulators.MDPSimIterator{(:s, :a, :sp, :r, :info, :t, :action_info), AdversarialDriving.AdversarialDrivingMDP, POMDPPolicies.FunctionPolicy{RiskSimulator.var"#85#86"{Vector{AdversarialDriving.Disturbance}}}, Random._GLOBAL_RNG, AutomotiveSimulator.EntityScene{AdversarialDriving.BlinkerState, AutomotiveSimulator.VehicleDef, Int64}}, cap_ex::Val{false}, prog::Nothing)
    @ POMDPSimulators ~/.julia/packages/POMDPSimulators/zxTz3/src/history_recorder.jl:185
 [11] simulate(sim::POMDPSimulators.HistoryRecorder, mdp::AdversarialDriving.AdversarialDrivingMDP, policy::POMDPPolicies.FunctionPolicy{RiskSimulator.var"#85#86"{Vector{AdversarialDriving.Disturbance}}}, init_state::AutomotiveSimulator.EntityScene{AdversarialDriving.BlinkerState, AutomotiveSimulator.VehicleDef, Int64})
    @ POMDPSimulators ~/.julia/packages/POMDPSimulators/zxTz3/src/history_recorder.jl:158
 [12] simulate(sim::POMDPSimulators.HistoryRecorder, mdp::AdversarialDriving.AdversarialDrivingMDP, policy::POMDPPolicies.FunctionPolicy{RiskSimulator.var"#85#86"{Vector{AdversarialDriving.Disturbance}}})
    @ POMDPSimulators ~/.julia/packages/POMDPSimulators/zxTz3/src/history_recorder.jl:137
 [13] training_phase(simx::AutoRiskSim; seed::Int64, epochs::Int64)
    @ RiskSimulator /media/luttkule/HDD/git/AutonomousRiskFramework.jl/RiskSimulator.jl/src/training_phase.jl:11
 [14] setup_ast(; sut::IntelligentDriverModel, scenario::Scenario, seed::Int64, state_proxy::Symbol, nnobs::Bool, which_solver::Symbol, noise_adjustment::Nothing, use_potential_based_shaping::Bool, rollout::typeof(POMDPStressTesting.AST.rollout))
    @ RiskSimulator /media/luttkule/HDD/git/AutonomousRiskFramework.jl/RiskSimulator.jl/src/ast.jl:268
 [15] top-level scope
    @ REPL[8]:1
 [16] top-level scope
    @ ~/.julia/packages/CUDA/5jdFl/src/initialization.jl:52

julia> search!(planner)
ERROR: UndefVarError: planner not defined
Stacktrace:
 [1] top-level scope
   @ REPL[9]:1
 [2] top-level scope
   @ ~/.julia/packages/CUDA/5jdFl/src/initialization.jl:52

julia> fail_metrics = failure_metrics(planner)
ERROR: UndefVarError: planner not defined
Stacktrace:
 [1] top-level scope
   @ REPL[10]:1
 [2] top-level scope
   @ ~/.julia/packages/CUDA/5jdFl/src/initialization.jl:52

julia> α = 0.2 # risk tolerance
0.2

julia> risk_metrics = metrics(planner, α)
ERROR: UndefVarError: planner not defined
Stacktrace:
 [1] top-level scope
   @ REPL[12]:1
 [2] top-level scope
   @ ~/.julia/packages/CUDA/5jdFl/src/initialization.jl:52

julia> risk = overall_area(planner, α=α)

Fix the warnings

A lot of warning messages like the following are printed when running RiskSimulator:

WARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:fourinvπ}) in module IrrationalConstants at irrationals.jl:180 overwritten in module
 StatsFuns on the same line (check for duplicate calls to `include`).                                                                                        
  ** incremental compilation may be fatally broken for this module **

Would be good to do some clean-ups later.

Fix UnicodePlots warning

Fixed via an update to POMDPModelTools v0.3.8 (that allowed UnicodePlots version 2+).

ColorSchemes dependency required in RiskSimulator.jl

The following dependency seems to be missing from the package. Externally installing it doesn't seem to suppress the warning.

┌ Warning: Package RiskSimulator does not have 
ColorSchemes in its dependencies:
│ - If you have RiskSimulator checked out for development and have
│   added ColorSchemes as a dependency but haven't updated your primary
│   environment's manifest file, try `Pkg.resolve()`.
│ - Otherwise you may need to report an issue with RiskSimulator
└ Loading ColorSchemes into RiskSimulator from 
project dependency, future warnings for RiskSimulator are suppressed.

Address method redefinition warnings that may break precompilation

WARNING: Method definition propagate(AutomotiveSimulator.Entity{AdversarialDriving.BlinkerState, D, I}, AdversarialDriving.BlinkerVehicleControl, AutomotiveSimulator.Roadway{T} where T<:Real, Float64) where {D, I} in module AdversarialDriving at C:\Users\mossr\.julia\dev\AdversarialDriving\src\driving_models.jl:140 overwritten in module RiskSimulator at C:\Users\mossr\Code\sisl\ast\Allstate\AutonomousRiskFramework\RiskSimulator.jl\src\scenarios\merging_roadway.jl:67.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition step_scene(AdversarialDriving.AdversarialDrivingMDP, AutomotiveSimulator.Scene{E} where E, Array{AdversarialDriving.Disturbance, 1}) in module AdversarialDriving at C:\Users\mossr\.julia\dev\AdversarialDriving\src\mdp.jl:126 overwritten in module RiskSimulator at C:\Users\mossr\Code\sisl\ast\Allstate\AutonomousRiskFramework\RiskSimulator.jl\src\scenario.jl:32.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition step_scene(AdversarialDriving.AdversarialDrivingMDP, AutomotiveSimulator.Scene{E} where E, Array{AdversarialDriving.Disturbance, 1}, Random.AbstractRNG) in module AdversarialDriving at C:\Users\mossr\.julia\dev\AdversarialDriving\src\mdp.jl:126 overwritten in module RiskSimulator at C:\Users\mossr\Code\sisl\ast\Allstate\AutonomousRiskFramework\RiskSimulator.jl\src\scenario.jl:32.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition cem_losses(Any, Any) in module POMDPStressTesting at C:\Users\mossr\Code\sisl\ast\POMDPStressTesting.jl\src\solvers\cem.jl:32 overwritten in module RiskSimulator at C:\Users\mossr\Code\sisl\ast\Allstate\AutonomousRiskFramework\RiskSimulator.jl\src\ast.jl:161.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition cem_losses##kw(Any, typeof(POMDPStressTesting.cem_losses), Any, Any) in module POMDPStressTesting at C:\Users\mossr\Code\sisl\ast\POMDPStressTesting.jl\src\solvers\cem.jl:32 overwritten in module RiskSimulator at C:\Users\mossr\Code\sisl\ast\Allstate\AutonomousRiskFramework\RiskSimulator.jl\src\ast.jl:161.
  ** incremental compilation may be fatally broken for this module **

This is due, in part, to certain method overrides.

IntelligentDriving in RiskSimulator causes Python version conflict

I was able to trace the Python version conflict I saw earlier to the IntelligentDriving package included in RiskSimulator.jl. I'm quite certain that I saw this issue long ago, and then I simply commented out using IntelligentDriving and also references to MPCDriver everywhere. Apparently, this is also what @shubhg1996 did in his recent commit which was reverted by @mossr.

I don't have a good sense of what Python packages IntelligentDriving needs and why, but would be good to do a proper fix rather than commenting things out (unless we really don't need it). It seems tricky though looking at the error log below which IIUC libraries like colorama and olefile require relatively old versions of Python and we need sth like 3.7.5.

UnsatisfiableError: The following specifications were found
to be incompatible with the existing python installation in your environment:

Specifications:

  - brotlipy -> python[version='3.10.*|3.4.*|3.6.12|3.6.12|3.7.10|3.7.10|3.7.12|3.7.9|3.6.9|3.6.9|3.6.9|3.6.9|3.7.*|3.8.*|3.9.*',build='0_73_pypy|1_73_pypy|2_73_pypy|4_73_pypy|5_73_pypy|5_73_pypy|0_73_pypy|1_73_pypy|0_73_pypy|3_73_pypy']
  - cffi -> python[version='2.7.*|3.5.*|3.6.*|3.6.12|3.6.12|3.7.10|3.7.10|3.7.12|>=3.10,<3.11.0a0|>=3.7,<3.8.0a0|>=3.8,<3.9.0a0|>=3.9,<3.10.0a0|>=3.6,<3.7.0a0|3.7.9|3.6.9|3.6.9|3.6.9|>=2.7,<2.8.0a0|3.6.9|>=3.5,<3.6.0a0|3.4.*',build='0_73_pypy|1_73_pypy|2_73_pypy|4_73_pypy|5_73_pypy|5_73_pypy|0_73_pypy|1_73_pypy|0_73_pypy|3_73_pypy']
  - colorama -> python[version='2.7.*|3.5.*|3.6.*|3.4.*']
  - cryptography -> python[version='3.10.*|3.6.12|3.6.12|3.7.10|3.7.10|3.7.12|3.7.9|3.6.9|3.6.9|3.6.9|3.6.9|3.8.*|3.7.*|3.9.*|3.4.*|<=3.3',build='0_73_pypy|1_73_pypy|2_73_pypy|4_73_pypy|5_73_pypy|5_73_pypy|0_73_pypy|1_73_pypy|0_73_pypy|3_73_pypy']
  - olefile -> python[version='2.7.*|3.5.*|3.6.*|3.4.*']
  - pyopenssl -> python[version='>=3.10,<3.11.0a0|>=3.9,<3.10.0a0']
  - pytorch -> python[version='2.7.*|3.5.*|3.6.*|3.6.12|3.6.12|3.7.10|3.7.10|3.7.12|>=3.10,<3.11.0a0|3.7.9|3.6.9|3.6.9|3.6.9|>=2.7,<2.8.0a0|3.6.9|>=3.5,<3.6.0a0|3.4.*|3.8.*|>=3.6|>=3.5|3.9.*|3.7.*|>=3.7|>=3.6,<3.7',build='0_73_pypy|1_73_pypy|2_73_pypy|4_73_pypy|5_73_pypy|5_73_pypy|0_73_pypy|1_73_pypy|0_73_pypy|3_73_pypy']

Your python: python=3.7.5

ScenarioSelection and IntelligentDriving can't be precompiled.

Error Message:

(@v1.6) pkg> precompile
Precompiling project...
  ✗ ScenarioSelection
  ✗ IntelligentDriving
  0 dependencies successfully precompiled in 16 seconds (365 already precompiled)