Pith. sign in

REVIEW 3 major objections 5 minor 2 cited by

TransitGPT: A Generative AI-based framework for interacting with GTFS data using Large Language Models

T0 review · 3 major / 5 minor · reviewed 2026-08-11 · deepseek-v4-flash

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

Pith's one-line read By prompting a large language model to write and run Python, TransitGPT answers ordinary-language questions about GTFS transit-schedule data, achieving 90–93% on a 100-task benchmark.

desk verdict Useful, well-scoped engineering paper with a plausible architecture and benchmark, but the evaluation's internal validity needs tightening before the 90/93 accuracy numbers can be read as robust. read the letter →

arxiv 2412.06831 v1 pith:R76HPS7H submitted 2024-12-07 cs.CL cs.AIstat.AP

Saipraneeth Devunuri , Lewis Lehe This is my paper · ORCID
classification cs.CLcs.AIstat.AP
keywords GTFSLargeLanguageModelsProgramSynthesisPromptEngineeringPublicTransitDataNaturalInterfacesCodeGenerationGPT
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

TransitGPT is a chatbot framework that lets people ask plain-language questions about public transit systems and get answers computed from GTFS schedule data. The key move is to have a large language model (LLM) write Python code that reads a preloaded GTFS feed, run that code in a sandbox, and then summarize the output for the user. No fine-tuning is involved; all guidance comes from prompts, including a schema description, sample rows, custom fuzzy-matching functions, and a few relevant examples selected per query. The authors built a 100-task benchmark across eight categories and report that the full system answers 90% of tasks correctly with one LLM and 93% with another, up from 74–84% in a zero-shot baseline. If that performance holds beyond the benchmark, the contribution is a low-cost recipe for making complex standardized datasets conversational.

What carries the argument

The load-bearing mechanism is the code-generation pipeline split into four stages: a lightweight moderation model blocks off-topic or malicious queries; a main LLM receives the user question, conversation history, three TF-IDF-selected few-shot examples, and a five-module system prompt (role, task instructions, GTFS field data types, sample feed rows, and custom fuzzy-matching functions); a sandboxed server executes the generated Python against a preprocessed Feed object; and a summary LLM turns the code's output dictionary into a human-friendly response. The full pipeline is prompt-only, with no fine-tuning and no access to the actual feed during generation.

What would settle it

Run TransitGPT on a held-out set of 50–100 transit questions written by riders and planners who have never seen the prompt set, with answers checked by an independent transit agency, and compare the task accuracy to the reported 90–93%; a large gap would show the benchmark was tuned from within. A second check: have multiple raters independently grade the original 100 outputs and measure inter-annotator agreement on the binary correct/incorrect scores.

Watch

Extended reading notes

Core claim

The paper's central claim is that a prompted LLM can serve as a reliable natural-language interface to GTFS Static data without seeing the feed and without fine-tuning. The system guides the LLM to output Python code that uses pandas, numpy, and geospatial libraries against a preprocessed Feed object, with strict instructions on GTFS data types, time conventions (seconds since midnight), and how to build a result dictionary with an answer, additional information, and an optional visualization. When the code errors, the traceback is sent back to the LLM for up to three correction rounds; a summary model then rewrites the raw output into a natural answer with stated assumptions. On the authors' 100-task benchmark, the full configuration scored 90% with GPT-4o and 93% with Claude-3.5-Sonnet, versus 74% and 84% without few-shot examples or retries, suggesting that dynamic examples and the error loop are what close most of the gap.

Load-bearing premise

The benchmark's ground-truth outputs were built by an LLM and manually corrected by the authors, and all 100 task scores were assigned by manual grading; if those ground truths or grades are systematically skewed toward the same prompt style TransitGPT uses, the 90% and 93% accuracy figures may not reproduce on independent real-world questions.

Editorial extensions

If this is right

  • Transit riders and planners can run system-level analyses—route lengths, headways, stop counts, fare comparisons—without writing code or mastering the GTFS specification.
  • Because the feed is never put into the model's context, the architecture sidesteps context-length limits and can work with feeds larger than any LLM window.
  • The open-source 100-task benchmark, organized into eight categories, gives other teams a shared test set for comparing natural-language interfaces to GTFS data.
  • The same design should transfer to other standardized mobility specifications, such as shared-bikeshare feeds or real-time transit feeds, by swapping the schema description and Feed object.
  • Each generated script is a reusable, commented analysis step, so a single chat answer also leaves behind a starting point for deeper exploration.

Reading between the lines

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

  • The pattern may generalize beyond transit: any domain with many interrelated standardized tables and a well-documented schema—permit records, clinical trial tables, building inventories—could get the same treatment, because the hard part the LLM is doing is schema reasoning, not arithmetic.
  • Reported accuracy is likely an optimistic bound, since the benchmark's ground-truth answers were drafted by an LLM and corrected by the same team that wrote the prompts; real-world questions phrased by transit riders would be a stricter test and might score lower.
  • A concrete stress test not in the paper: benchmark performance on a single very large feed, such as one with millions of stop-time rows, where join-heavy queries written by the LLM may time out and push the three-minute execution limit.
  • The framework deliberately excludes door-to-door routing; a hybrid that hands routing queries to a dedicated router while keeping TransitGPT for system-level questions would cover a larger share of how users actually interact with transit information.
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.

Referee Report

3 major / 5 minor

Summary. This paper presents TransitGPT, an open-source framework that answers natural-language queries about GTFS Static feeds by prompting an LLM to generate Python code, executing that code in a sandbox against a preprocessed feed object, and summarizing the results with a second LLM. The architecture includes a moderation step, dynamic few-shot selection from 12 curated examples, custom fuzzy-matching/geocoding functions, an error-handling retry loop, and a summary module. The authors evaluate GPT-4o and Claude-3.5-Sonnet in a zero-shot baseline and in a 'TransitGPT+' configuration on an author-created benchmark of 100 tasks across eight categories and five U.S. transit feeds, reporting accuracies of 90% and 93% for the TransitGPT+ configuration, together with token and time metrics. The paper also states its scope limitations, including GTFS-Static-only data and no routing functionality.

Significance. The contribution is timely and practical: a prompt-only program-synthesis solution for transit data, a new 100-task benchmark, and open-source code that others can run and extend. The paper is careful to distinguish its approach from RAG and full-feed prompting, and the prompt design details (data types, custom functions, feed samples) are concrete and valuable. The strongest aspects are the open-source code and benchmark release and the clearly described architecture. However, the headline accuracy numbers currently rest on an evaluation whose internal validity is not fully established: the benchmark ground truth is generated with LLM assistance and manual correction, grading is manual without inter-rater reliability, there are no confidence intervals or repeated runs, and the few-shot examples are not stated to be disjoint from the test tasks. These are fixable with additional analysis and documentation, but they must be addressed before the paper's central claim is taken as established.

major comments (3)
  1. [Section 3, Step 2(iii); Section 4.1] The paper never states that the 12 curated few-shot question-answer pairs are disjoint from the 100 benchmark tasks (Qi, Yi, Oi). If any few-shot pair or a templated variant of it appears among the benchmark tasks, the Main LLM in TransitGPT+ would receive the reference code Yi before generating its own code for that task, guaranteeing success on those items and inflating the reported 90% and 93% accuracies. Please explicitly confirm disjointness, list the 12 few-shot examples in an appendix (or otherwise make them public), and re-run the evaluation if any overlap exists.
  2. [Section 4.1] The ground-truth outputs Oi are produced by executing Yi, where Yi is 'request[ed] from an LLM' and then 'manually correct[ed]' by the authors. The paper does not say which LLM drafted Yi, whether the drafting model was one of the two evaluated models, or whether the manual corrections were substantial. Because the benchmark queries and the prompt (including the five Custom Functions) were authored by the same team, this creates a risk that the evaluation measures the model's ability to reproduce the authors' coding style and helper-function usage rather than general GTFS question-answering. Please specify the drafting model, report the rate and extent of manual corrections, and provide independent validation of a random sample of Oi values (e.g., by a second annotator or by an alternative computation method).
  3. [Section 4.2 and Table 2] The accuracy results are reported from a single run per task with binary manual grading, and no confidence intervals, repeated runs, or inter-rater reliability statistics are given. With per-category sample sizes of 8-22, the category-level rates (e.g., Fare Analysis: 75% for both configurations for GPT-4o; Performance Metrics: 93% baseline vs. 87% TransitGPT+ for Claude-3.5-Sonnet) are noisy, and the overall 90%/93% estimates lack uncertainty bounds. Please report confidence intervals (or repeated runs with variance) and provide a grading rubric, plus a second grader on at least a subset to compute inter-rater agreement.
minor comments (5)
  1. [Section 4.2, Table 2 text] The sentence 'TransitGPT+ outperforms the baseline in all categories except for both LLMs' is not supported by Table 2; for Claude-3.5-Sonnet, Basic Data Operations (80 vs. 80) and Fare Analysis (88 vs. 88) tie, and Performance Metrics decreases (93 vs. 87), while GPT-4o's Fare Analysis ties (75 vs. 75). Please correct this sentence.
  2. [Section 4.2] Because the baseline is zero-shot with zero retries and TransitGPT+ adds both few-shot examples and retries, the observed improvement cannot be attributed to either component; an ablation would clarify the individual contributions.
  3. [Section 4.1 and Appendix B] The paper should pin the exact versions or download dates of the five GTFS feeds used in the benchmark, as well as the code version (e.g., a commit hash or archived DOI), so that the benchmark is reproducible.
  4. [Section 3 and footnotes] There are small presentation issues: footnote 3 has 'poltly.express' instead of 'plotly.express', the find_stops_by_street description says 'Maint Street.' instead of 'Main Street', and footnote 6 has 'Nominatum' instead of 'Nominatim'.
  5. [Section 2.3 and Table 1] The distinction between the prior 'GTFS Retrieval' benchmark (Devunuri et al., 2024b) and the new 100-task benchmark should be stated explicitly, since Table 1's categories appear to overlap with the earlier work; please clarify which tasks are new to this paper.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the paper's claim rests on an externally executed benchmark, and no claimed result reduces by construction to its inputs.

full rationale

TransitGPT's central claim is an empirical evaluation result, not a derivation. The 100-task benchmark defines each task by a query Qi, feed Fi, input Xi, reference code Yi, and output Oi; Oi is obtained by executing Yi on a local Python interpreter, not by running TransitGPT, so the benchmark is external to the system being evaluated. The paper does not fit any parameter to the benchmark and then rename that fit as a prediction; the reported accuracies are manually graded responses. Self-citations to Devunuri et al. (2024b) and Devunuri and Lehe (2024b) provide background and scope context (prior GTFS benchmarks and error surveys) but are not load-bearing: no uniqueness theorem, ansatz, or claimed derivation is imported from those papers. The few-shot examples are selected from twelve curated question-answer pairs (Section 3, Step 2(iii)), and the paper does not state whether these pairs are disjoint from the 100 benchmark tasks; without evidence of overlap this is a potential contamination or validity risk, not a demonstrated circular reduction. Likewise, drafting Yi with an LLM and manually correcting it (Section 4.1) is a benchmark-construction choice that raises concerns about representativeness and grading objectivity, but it does not make the evaluation logically equivalent to the input. Accordingly, the appropriate circularity finding is none.

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

No physical or conceptual entities are invented. The central evaluation rests on hand-set hyperparameters and unvalidated benchmark assumptions, listed above.

free parameters (6)
  • Temperature settings = 0.3 (Main), 0.5 (retries), 0.7 (Moderation/Summary)
    Hand-chosen in Section 4.2. The authors observed that lower temperatures impair self-correction, so retries use a higher value.
  • Number of dynamic few-shot examples = 3
    Chosen in Section 3, Step 2 to balance token cost, response time, and relevance.
  • Max retries = 3
    Hand-chosen cap on the error-feedback loop in Section 3 and Section 4.2.
  • Timeout = 3 minutes
    Execution time limit for code in Step 3, set in Section 4.2.
  • Fuzzy matching threshold = 80 (default)
    Default similarity threshold for find_stops_by_full_name and related helper functions, shown in Figure 5.
  • Geocoding radius and stop count = 200 meters, 5 stops (example)
    Radius used in the example for find_stops_by_address; chosen by hand in the prompt example.
assumptions (4)
  • domain assumption LLMs can generate syntactically correct, executable Python code for GTFS queries when given a detailed system prompt.
    The entire architecture in Steps 2 and 3 depends on this. The paper evaluates it empirically on 100 tasks but does not prove it.
  • domain assumption The preprocessed Feed object and gtfs_kit parsing faithfully represent GTFS semantics, including recomputed shape_dist_traveled when absent.
    Appendix B preprocessing changes or removes data (dummy entries, recomputed distances), and answers from TransitGPT reflect the preprocessed feed, not necessarily the raw agency feed.
  • domain assumption The 100 benchmark tasks are representative of real user questions about transit systems.
    Section 4.1 states that queries were manually written by the authors. No external validation of representativeness is provided.
  • domain assumption Manual binary grading of answers is consistent and unbiased.
    Section 4.2 says all grading is manual, including visual inspection of visualizations. No inter-rater agreement or rubric details are given.

how reviews work

0 comments
Cite this review

Pith. "Pith review of TransitGPT: A Generative AI-based framework for interacting with GTFS data using Large Language Models." pith.science (2026). https://pith.science/paper/R76HPS7H

@misc{pith2026241206831,
  author       = {Pith},
  title        = {Pith review of: TransitGPT: A Generative AI-based framework for interacting with GTFS data using Large Language Models},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/R76HPS7H}},
  note         = {Machine review of arXiv:2412.06831}
}
read the original abstract

This paper introduces a framework that leverages Large Language Models (LLMs) to answer natural language queries about General Transit Feed Specification (GTFS) data. The framework is implemented in a chatbot called TransitGPT with open-source code. TransitGPT works by guiding LLMs to generate Python code that extracts and manipulates GTFS data relevant to a query, which is then executed on a server where the GTFS feed is stored. It can accomplish a wide range of tasks, including data retrieval, calculations, and interactive visualizations, without requiring users to have extensive knowledge of GTFS or programming. The LLMs that produce the code are guided entirely by prompts, without fine-tuning or access to the actual GTFS feeds. We evaluate TransitGPT using GPT-4o and Claude-3.5-Sonnet LLMs on a benchmark dataset of 100 tasks, to demonstrate its effectiveness and versatility. The results show that TransitGPT can significantly enhance the accessibility and usability of transit data.

Figures

Figures reproduced from arXiv: 2412.06831 by the authors.

Figure 1
Figure 1. Demonstrations of ‘TransitGPT’ in generating responses for GTFS data retrieval tasks. Sample visualizations [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. , is designed for answering questions about systems [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Extended TransitGPT Architecture Step 0: Pre-Query 6 [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figures from the paper (7 more)
Figure 4
Figure 4. Figure 4: Moderation Prompt Step 2: Main LLM 2Note it would be possible to load the raw GTFS feed into the sandbox, but the feeds are pre-prepared to save time when the user chooses an agency to investigate. 3The libraries are gtfs_kit , pandas , numpy , geopandas , geopy , polt…
Figure 5
Figure 5. Figure 5: Excerpts from Main prompt covering various modules. Each module is wrapped in an [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]
Figure 6
Figure 6. Figure 6: Error Prompt Template 6For geocoding, we use the Google Maps geocoding API, which we found outperformed the open-source Nominatum Python library. 10 [PITH_FULL_IMAGE:figures/full_fig_p010_6.png]
Figure 7
Figure 7. Figure 7: Demonstration of error handling and feedback loop. The query is ‘Find the busiest date (date with the most number [PITH_FULL_IMAGE:figures/full_fig_p011_7.png]
Figure 8
Figure 8. Figure 8: Summary Prompt Champaign-Urbana Mass Transit District (CUMTD, 23 tasks), Dallas Area Rapid Transit (DART, 32 tasks), and Chicago Transit Authority (CTA, 12 tasks). These agencies were selected to ensure diversity in the inputs, as their feeds differ significantly in te…
Figure 9
Figure 9. Figure 9: Example of code output and summary response. [PITH_FULL_IMAGE:figures/full_fig_p014_9.png]
Figure 10
Figure 10. Figure 10: Example task and its components. For ‘Moderation’ and ‘Summary’ LLMs that perform more creative tasks than code generation, we use a temperature of 0.7. • max_tokens: Limits the maximum number of tokens allowed for generation by the LLM. We set the “max tokens" parame…

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 2 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Toward LLM-Agent-Based Modeling of Transportation Systems: A Conceptual Framework

    cs.AI 2024-12 conditional novelty 5.0 of 10

    LLM-driven agents with profiles, memory, and feedback loops can generate plausible daily travel activities and learn to adjust commute timing in a small proof-of-concept, pointing toward a new direction for agent-base...

  2. Large Language Model Powered Intelligent Urban Agents: Concepts, Capabilities, and Applications

    cs.MA 2025-07 conditional novelty 4.0 of 10

    The paper defines urban LLM agents, surveys their sensing, memory, reasoning, execution, and learning workflows, and organizes their applications across planning, transportation, environment, safety, and society.

Reference graph

Works this paper leans on

40 extracted references · 10 canonical work pages · cited by 2 Pith papers

  1. [3]

    URL:http://arxiv.org/abs/2408.14717, arXiv:2408.14717

    Text2SQL is Not Enough: Unifying AI and Databases with TAG. URL:http://arxiv.org/abs/2408.14717, arXiv:2408.14717. Brown, T.B., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., Agarwal, S., Herbert-Voss, A., Krueger, G., Henighan, T., Child, R., Ramesh, A., Ziegler, D.M., Wu, J., Winter, C., H...

    arXiv

  2. [7]

    URL:http://arxiv.org/abs/2310.08034, doi:10.48550/arXiv.2310.08034, arXiv:2310.08034

    Receive, Reason, and React: Drive as You Say with Large Language Models in Autonomous Vehicles. URL:http://arxiv.org/abs/2310.08034, doi:10.48550/arXiv.2310.08034, arXiv:2310.08034. Da, L., Gao, M., Mei, H., Wei, H.,

    arXiv doi:10.48550/arxiv.2310.08034

  3. [8]

    doi:10.48550/arXiv

    LLM Powered Sim-to-real Transfer for Traffic Signal Control. doi:10.48550/arXiv. 2308.14284. Devunuri, S., Lehe, L., 2024a. GTFS Segments: A Fast and Efficient Library to Generate Bus Stop Spacings. Journal of Open Source Software 9,

    arXiv doi:10.48550/arxiv.2308.14284

  4. [11]

    URL: http://arxiv.org/abs/2306.01987, doi:10.48550/arXiv.2306.01987, arXiv:2306.01987

    Prompting Is All You Need: Automated Android Bug Replay with Large Language Models. URL: http://arxiv.org/abs/2306.01987, doi:10.48550/arXiv.2306.01987, arXiv:2306.01987. Fortin, P., Morency, C., Trépanier, M.,

    arXiv doi:10.48550/arxiv.2306.01987

  5. [13]

    URL:http://arxiv.org/abs/2307.07162, doi:10.48550/arXiv.2307.07162, arXiv:2307.07162

    Drive Like a Human: Rethinking Autonomous Driving with Large Language Models. URL:http://arxiv.org/abs/2307.07162, doi:10.48550/arXiv.2307.07162, arXiv:2307.07162. Gao, Y., Xiong, Y., Gao, X., Jia, K., Pan, J., Bi, Y., Dai, Y., Sun, J., Wang, M., Wang, H.,

    arXiv doi:10.48550/arxiv.2307.07162

  6. [14]

    URL: http://arxiv.org/abs/2312.10997, doi:10.48550/arXiv.2312

    Retrieval-Augmented Generation for Large Language Models: A Survey. URL: http://arxiv.org/abs/2312.10997, doi:10.48550/arXiv.2312. 10997, arXiv:2312.10997. Haluptzok, P., Bowers, M., Kalai, A.T.,

    arXiv doi:10.48550/arxiv.2312.10997

  7. [15]

    URL: http: //arxiv.org/abs/2207.14502, arXiv:2207.14502

    Language Models Can Teach Themselves to Program Better. URL: http: //arxiv.org/abs/2207.14502, arXiv:2207.14502. Hendrycks, D., Burns, C., Basart, S., Zou, A., Mazeika, M., Song, D., Steinhardt, J.,

    arXiv

  8. [16]

    URL: http://arxiv.org/abs/2009.03300, doi:10.48550/arXiv.2009.03300, arXiv:2009.03300

    Measuring Massive Multitask Language Understanding. URL: http://arxiv.org/abs/2009.03300, doi:10.48550/arXiv.2009.03300, arXiv:2009.03300. Hsieh, C.P., Sun, S., Kriman, S., Acharya, S., Rekesh, D., Jia, F., Zhang, Y., Ginsburg, B.,

    arXiv doi:10.48550/arxiv.2009.03300 2009

Show all 40 references
  1. [17]

    2404.06654, arXiv:2404.06654

    RULER: What’s the Real Context Size of Your Long-Context Language Models? URL: http://arxiv.org/abs/2404.06654, doi:10.48550/arXiv. 2404.06654, arXiv:2404.06654. Khatry, A., Cahoon, J., Henkel, J., Deep, S., Emani, V., Floratou, A., Gulwani, S., Le, V., Raza, M., Shi, S., Sing...

    doi arXiv

  2. [18]

    URL: http: //arxiv.org/abs/2305.01598, doi:10.48550/arXiv.2305.01598, arXiv:2305.01598

    From Words to Code: Harnessing Data for Program Synthesis from Natural Language. URL: http: //arxiv.org/abs/2305.01598, doi:10.48550/arXiv.2305.01598, arXiv:2305.01598. Kunama, N., Worapan, M., Phithakkitnukoon, S., Demissie, M.,

    doi arXiv

  3. [19]

    GTFS-Viz: Tool for preprocessing and visualizing GTFS data, in: Proceedings of the 2017 ACM International Joint Conference on Pervasive and Ubiquitous Computing and Proceedings of the 2017 ACM International Symposium on Wearable Computers, ACM, Maui Hawaii. pp. 388–396. URL: h...

    2017

  4. [20]

    URL:http://arxiv.org/ abs/2005.11401, doi:10.48550/arXiv.2005.11401, arXiv:2005.11401

    Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. URL:http://arxiv.org/ abs/2005.11401, doi:10.48550/arXiv.2005.11401, arXiv:2005.11401. 22 Liu, D., Guo, J., Gu, Y., King, M., Han, L.D., Brakewood, C.,

    2005 doi arXiv

  5. [21]

    URL:http://arxiv.org/abs/2405.02760, arXiv:2405.02760

    GTFS2STN: Analyzing GTFS Transit Data by Generating Spatiotemporal Transit Network. URL:http://arxiv.org/abs/2405.02760, arXiv:2405.02760. Liu, N.F., Lin, K., Hewitt, J., Paranjape, A., Bevilacqua, M., Petroni, F., Liang, P.,

    arXiv

  6. [22]

    URL:http://arxiv.org/abs/2307.03172, doi:10.48550/arXiv.2307.03172, arXiv:2307.03172

    Lost in the Middle: How Language Models Use Long Contexts. URL:http://arxiv.org/abs/2307.03172, doi:10.48550/arXiv.2307.03172, arXiv:2307.03172. McHugh, B.,

    doi arXiv

  7. [23]

    IEEE Transactions on Intelligent Transportation Systems , 1–16URL:https://ieeexplore.ieee

    The Crossroads of LLM and Traffic Control: A Study on Large Language Models in Adaptive Traffic Signal Control. IEEE Transactions on Intelligent Transportation Systems , 1–16URL:https://ieeexplore.ieee. org/document/10768207, doi:10.1109/TITS.2024.3498735. Mumtarin, M., Chowdh...

  8. [24]

    URL:http://arxiv.org/abs/2308.13563, doi:10.48550/arXiv.2308.13563, arXiv:2308.13563

    Large Language Models in Analyzing Crash Narratives – A Compara- tive Study of ChatGPT, BARD and GPT-4. URL:http://arxiv.org/abs/2308.13563, doi:10.48550/arXiv.2308.13563, arXiv:2308.13563. Oliveira, A., Espadoto, M., Hirata Jr, R., Damaceno, R., Cesar, R.,

    doi arXiv

  9. [25]

    URL:http://arxiv.org/abs/2303.08774, doi:10.48550/arXiv.2303.08774, arXiv:2303.08774

    GPT-4 Technical Report. URL:http://arxiv.org/abs/2303.08774, doi:10.48550/arXiv.2303.08774, arXiv:2303.08774. Para, S., Wirotsasithon, T., Jundee, T., Demissie, M.G., Sekimoto, Y., Biljecki, F., Phithakkitnukoon, S.,

    doi arXiv

  10. [26]

    Public Transport URL: https: //link.springer.com/10.1007/s12469-024-00362-x, doi:10.1007/s12469-024-00362-x

    G2Viz: An online tool for visualizing and analyzing a public transit system from GTFS data. Public Transport URL: https: //link.springer.com/10.1007/s12469-024-00362-x, doi:10.1007/s12469-024-00362-x. Park, Y., Mount, J., Liu, L., Xiao, N., Miller, H.J.,

    doi

  11. [27]

    International Journal of Geographical Information Science 34, 367–392

    Assessing public transit performance using real-time data: Spa- tiotemporal patterns of bus operation delays in Columbus, Ohio, USA. International Journal of Geographical Information Science 34, 367–392. URL:https://doi.org/10.1080/13658816.2019.1608997, doi:10.1080/13658816.2...

  12. [28]

    URL: http://arxiv.org/abs/2311.09635, arXiv:2311.09635

    Evaluating In-Context Learning of Libraries for Code Generation. URL: http://arxiv.org/abs/2311.09635, arXiv:2311.09635. Pereira, R.H.M., Andrade, P.R., Vieira, J.P.B.,

    arXiv

  13. [29]

    Journal of Geographical Systems 25, 453–466

    Exploring the time geography of public transport networks with the gtfs2gps package. Journal of Geographical Systems 25, 453–466. URL: https://doi.org/10.1007/s10109-022-00400-x, doi:10.1007/s10109-022-00400-x. Pereira, R.H.M., Saraiva, M., Herszenhut, D., Braga, C.K.V., Conway, M.W.,

    doi

  14. [30]

    Findings URL: https://findingspress.org/article/ 21262-r5r-rapid-realistic-routing-on-multimodal-transport-networks-with-r-5-in-r , doi:10.32866/001c.21262

    R5r: Rapid Realistic Rout- ing on Multimodal Transport Networks with R 5 in R. Findings URL: https://findingspress.org/article/ 21262-r5r-rapid-realistic-routing-on-multimodal-transport-networks-with-r-5-in-r , doi:10.32866/001c.21262. Prajapati, A., Bhattrai, N., Bajracharya, T.,

    doi

  15. [32]

    URL:http://arxiv.org/abs/2305.14930, doi:10.48550/arXiv.2305.14930, arXiv:2305.14930

    In-Context Impersonation Reveals Large Language Models’ Strengths and Biases. URL:http://arxiv.org/abs/2305.14930, doi:10.48550/arXiv.2305.14930, arXiv:2305.14930. Schick, T., Dwivedi-Yu, J., Dessì, R., Raileanu, R., Lomeli, M., Zettlemoyer, L., Cancedda, N., Scialom, T.,

    doi arXiv

  16. [33]

    URL:http://arxiv.org/abs/2302.04761, arXiv:2302.04761

    Toolformer: Language Models Can Teach Themselves to Use Tools. URL:http://arxiv.org/abs/2302.04761, arXiv:2302.04761. Syed, U., Light, E., Guo, X., Zhang, H., Qin, L., Ouyang, Y., Hu, B.,

    arXiv

  17. [34]

    URL:http://arxiv.org/ abs/2408.08302, arXiv:2408.08302

    Benchmarking the Capabilities of Large Language Models in Transportation System Engineering: Accuracy, Consistency, and Reasoning Behaviors. URL:http://arxiv.org/ abs/2408.08302, arXiv:2408.08302. Wang, J., Shalaby, A.,

    arXiv

  18. [35]

    URL:http://arxiv.org/abs/2410.15016, arXiv:2410.15016

    Transit Pulse: Utilizing Social Media as a Source for Customer Feedback and Information Extraction with Large Language Model. URL:http://arxiv.org/abs/2410.15016, arXiv:2410.15016. Xu, B., Yang, A., Lin, J., Wang, Q., Zhou, C., Zhang, Y., Mao, Z.,

    arXiv

  19. [36]

    URL: http://arxiv.org/abs/2305.14688, doi:10.48550/arXiv.2305.14688, arXiv:2305.14688

    ExpertPrompting: Instructing Large Lan- guage Models to be Distinguished Experts. URL: http://arxiv.org/abs/2305.14688, doi:10.48550/arXiv.2305.14688, arXiv:2305.14688. Yan, X., Bejleri, I., Zhai, L.,

    doi arXiv

  20. [38]

    URL: http://arxiv.org/abs/2210.03629, doi:10.48550/arXiv.2210.03629, arXiv:2210.03629

    ReAct: Synergizing Reasoning and Acting in Language Models. URL: http://arxiv.org/abs/2210.03629, doi:10.48550/arXiv.2210.03629, arXiv:2210.03629. Zan, D., Chen, B., Yang, D., Lin, Z., Kim, M., Guan, B., Wang, Y., Chen, W., Lou, J.G.,

    doi arXiv

  21. [39]

    URL:http://arxiv.org/abs/2206.06888, arXiv:2206.06888

    CERT: Continual Pre-Training on Sketches for Library-Oriented Code Generation. URL:http://arxiv.org/abs/2206.06888, arXiv:2206.06888. Zhang, B., Ye, Y., Du, G., Hu, X., Li, Z., Yang, S., Liu, C.H., Zhao, R., Li, Z., Mao, H., 2024a. Benchmarking the Text- to-SQL Capability of L...

    arXiv

  22. [40]

    ChatGPT is on the Horizon: Could a Large Language Model be Suitable for Intelligent Traffic Safety Research and Applications? URL: http://arxiv.org/abs/2303.05382, doi:10.48550/arXiv.2303.05382, arXiv:2303.05382. 24

    doi arXiv

  23. [2003]

    Information Processing & Management 39, 45–65

    An information-theoretic perspective of tf–idf measures. Information Processing & Management 39, 45–65. URL: https://www.sciencedirect.com/science/article/pii/S0306457302000213, doi:10.1016/S0306-4573(02)00021-3. Anthropic,

    doi

  24. [2010]

    URL: https://sf.streetsblog.org/2010/01/05/ how-google-and-portlands-trimet-set-the-standard-for-open-transit-data

    How Google and Portland’s TriMet Set the Standard for Open Tran- sit Data - Streetsblog San Francisco. URL: https://sf.streetsblog.org/2010/01/05/ how-google-and-portlands-trimet-set-the-standard-for-open-transit-data . 23 Salewski, L., Alaniz, S., Rio-Torto, I., Schulz, E., A...

    2010

  25. [2016]

    Journal of Public Transportation 19, 18–37

    Innovative GTFS Data Application for Transit Network Analysis Using a Graph- Oriented Method. Journal of Public Transportation 19, 18–37. URL:https://www.sciencedirect.com/science/article/ pii/S1077291X22001151, doi:10.5038/2375-0901.19.4.2. Fu, D., Li, X., Wen, L., Dou, M., C...

    doi

  26. [2017]

    PLOS ONE 12, e0185333

    An efficient General Transit Feed Specification (GTFS) enabled algorithm for dynamic transit accessibility analysis. PLOS ONE 12, e0185333. URL:https://journals.plos.org/plosone/article?id=10.1371/ journal.pone.0185333, doi:10.1371/journal.pone.0185333. Feng, S., Chen, C.,

    doi

  27. [2020]

    URL:http://arxiv.org/abs/2005.14165, doi:10.48550/arXiv.2005.14165, arXiv:2005.14165

    Language Models are Few-Shot Learners. URL:http://arxiv.org/abs/2005.14165, doi:10.48550/arXiv.2005.14165, arXiv:2005.14165. Cobbe, K., Kosaraju, V., Bavarian, M., Chen, M., Jun, H., Kaiser, L., Plappert, M., Tworek, J., Hilton, J., Nakano, R., Hesse, C., Schulman, J.,

    2005 doi arXiv

  28. [2021]

    URL:http://arxiv.org/abs/2110.14168, doi:10.48550/arXiv.2110.14168, arXiv:2110.14168

    Training Verifiers to Solve Math Word Problems. URL:http://arxiv.org/abs/2110.14168, doi:10.48550/arXiv.2110.14168, arXiv:2110.14168. Crothers, E., Japkowicz, N., Viktor, H.,

    doi arXiv

  29. [2022]

    Journal of Transport Geography 98, 103218

    A spatiotemporal analysis of transit accessibility to low-wage jobs in Miami-Dade County. Journal of Transport Geography 98, 103218. URL: https://www.sciencedirect.com/science/article/pii/ S0966692321002714, doi:10.1016/j.jtrangeo.2021.103218. Yao, S., Zhao, J., Yu, D., Du, N....

  30. [2023]

    URL: http://arxiv.org/abs/2210.07321, doi:10.48550/arXiv.2210.07321, arXiv:2210.07321

    Machine Generated Text: A Comprehensive Survey of Threat Models and Detection Methods. URL: http://arxiv.org/abs/2210.07321, doi:10.48550/arXiv.2210.07321, arXiv:2210.07321. Cui, C., Ma, Y., Cao, X., Ye, W., Wang, Z.,

    doi arXiv

  31. [2024]

    URL:http://arxiv.org/abs/2402.00157, arXiv:2402.00157

    Large Language Models for Mathematical Reasoning: Progresses and Challenges. URL:http://arxiv.org/abs/2402.00157, arXiv:2402.00157. Aizawa, A.,

    arXiv

  32. [6306]

    Devunuri, S., Lehe, L., 2024b

    URL:https://joss.theoj.org/papers/10.21105/joss.06306, doi:10.21105/joss.06306. Devunuri, S., Lehe, L., 2024b. A Survey of Errors in GTFS Static Feeds from the United States. Findings URL: https://findingspress.org/article/116694-a-survey-of-errors-in-gtfs-static-feeds-from-th...

Pith tools

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