Chris von Csefalvay is a computational epidemiologist/data scientist working at the intersection of AI, epidemiology and public health.

Chris von Csefalvay

It appears that in what is clearly a wonderful little PR stunt, a Polish rum company managed to do a Sophia and appoint an ‘AI-driven’ ‘robot’ as its ‘CEO’.  The other guilty party to this pile of steaming bovine excrement is Hanson Robotics, famous for giving us Sophia, the “world’s first robot citizen”. Most of what I’m saying here goes just as well for Sophia.

The skeuomorphic fallacy

Over at the work blog, I’m discussing what knowledge means for large language models (LLMs), and the ways in which we can leverage this knowledge dividend for better inference.  Read the full post here.

Asemantic Induction of Hallucinations in LLMs

There’s a style of visual design I’m inordinately fond of called Raygun Gothic. It’s hard to describe what the hell exactly one needs to be on to enjoy it, but think of it like the aesthetic from the latter Fallout games with a more optimistic outlook on the future. Gibson described it as “the future that never was”, and I think that’s a pretty apt description. We get these competing futures in technology all the time.

Prompt Engineering: The Art of Yesterday

Say you’re busing tables and you’re trying to pass someone in a wheelchair. What do you do? Do you say “excuse me” and wait for them to move? Do you say “excuse me” and then try to pass them? Do you just try to pass them? Do you say nothing and just try to pass them? All of these are, actually, pretty legitimate answers. Now, say you’re a robot.

What I learned from getting bodied by a robot.

There’s a notion in artificial intelligence known as Moravec’s paradox: it’s relatively easy to teach a computer to play chess or checkers at a pretty decent level, but near impossible to teach it something as trivial as bipedal motion. (Hassabis 2017) The sensorimotor tasks that our truly wonderful brains have mastered by our second birthday are much harder to teach a computer than something arguably as ‘complex’ as beating a chess grandmaster.

The hardest AI problem you’ve never heard of.

The year is 1959. Eisenhower is on his second term, Castro just kicked Batista out of the country and Ray Charles’s Let the Good Times Roll is topping the charts.

The 95% myth

There’s something special about language. It is ‘our own’, it is ‘us’, in a profound way, and quite surprisingly, more so than art. I was deeply struck by this when I first saw reactions to large generative language models that created realistic, human-ish prose.

Beyond Broca

The knowledge dividend of large language models

In my latest post for the Starschema blog, I discuss the end of dashboards, and what comes next:  Read the full post here.

As we may see: the world after dashboards

There might be valid concerns about the mRNA vaccines. Then there are the clearly insane ones, such as the claims that it involves the injection of a microchip. The argument that mRNA vaccines are a form of ‘gene therapy’ are somewhere in the middle, and that makes responding to it somewhat difficult.

Why the COVID-19 vaccines are not gene therapy

The awesome thing about language is that, well, we all mostly speak it, to some extent or another. This gives us an immensely powerful tool to manipulate transformational tasks. For the purposes of this post, I consider a transformational task to be essentially anything that takes an input and is largel intended to return some version of the same thing. This is not a very precise definition, but it will have to do for now.

LAIR - Language As Intermediate Representation

In the first four entries (1 2 3 4) of this sequence, I have focused primarily on what LLMs aren’t, can’t, won’t, wouldn’t and shouldn’t. It’s probably time to conclude this series by that much awaited moment in all stories, where the darkest night finally turns into a glorious dawn, where we finally arrive at the promised land, where we finally get to talk about what LLMs
<em>
 could
</em>
be.  What I see as the most successful potential model of

Teams of Rivals

Tip  If you’re here for the DOI matching script, the link is here. Quarto is a great tool for reproducible research. It is also a great tool for building websites. After about a decade of Wordpress-based websites, I’ve moved to Quarto primarily for two reasons. First, most of my content is largely static.

Quarto project scripts are awesomeness

It’s not every day that you find out you have climbed the exalted heights of another discipline. My work is pretty interdisciplinary, but it shocked me, too, that I’m apparently holding forth on neoliberalism and the epistemic question in African universities (archive link):  This, of course, came at some surprise to me, as I have never written anything on the topic.

Stochastic parrots, cap and gown edition

The temple of Asclepios, the Greek god of healing arts and medicine, at Epidaurus was pretty much the ancient Greek world’s equivalent of the Mayo Clinic. It then tells us a lot about the Greek worldview of healing that one of the things the temple complex prominently featured was a theatre. The Greeks believed in drama therapy, but in perhaps a slightly different way of how we think of it today.

The Moral Pulse of the Machine

I have probably spent more time looking at Poussin’s
<em>
 Dance to the Music of Time
</em>
than any other work of art. Sneaking off to the Wallace Collection in London and just looking at the
<em>
 Dance
</em>
was my comfort activity while living in London – a time that was not exactly devoid of its trials. It’s not, by any measure,
<em>
 great
</em>
art, insofar as such judgments can be made with any objectivity.

The Lyre of Hephaestus

My recent post on the Starschema blog discusses the need for better data products to tackle future pandemic challenges:  Read the full post here.

Data for the next pandemic

In a recent paper that has attracted the interest of popular media as well, Fabio Urbina and colleagues examined the use (or rather, the abuse) of computational chemistry models of toxicity for generating toxic compounds and potential chemical agent candidates.(Urbina et al. 2022) Urbina and colleagues conclude that Urbina, Fabio, Filippa Lentzos, Cédric Invernizzi, and Sean Ekins. 2022.

A different shade of grey

Every year, the Commandant of the Marine Corps publishes a reading list of books that often only bear on warfighting tangentially at best. The idea behind this is that those entrusted with the lives of servicemembers should have an understanding of the world that goes beyond the profession of arms. In much the same way, I have been advising data scientists to go beyond professional literature.

Five non-data-science books for data scientists

I used to be on Quora. I’m not anymore. But I used to be. And I wrote some answers. Here are some of my favourites, categorised by field… sort of.
<strong>
 AI
</strong>
If I wrote an AI and trained it to score 200 on a standardized IQ test, what could a human of 100 IQ still do better?   Read the full answer here. Will true AI come before the ability to completely simulate a human brain? Is there a difference?   Read the full answer here.

My favourite Quora answers

As the new Omicron variant of concern of COVID-19 emerged over Thanksgiving week (of all times!), attention has been turning to Paxlovid (PF-07321332). If, like me, you torment yourself by perusing conspiracy theories, you might have heard it referred to as Pfizermectin.

Peace, love, Paxlovid and ‘Pfizermectin’

In the middle of the green and pleasant countryside of England lies a small piece of commons –– land, that is, over which a number of people share certain rights. In this hypothetical scenario, it’s six farmers,  to . Each of them has a hypothetical cow, which differs from ordinary cows in that it grazes a fixed unit, and produces a fixed amount of milk (unlike real cows, which vary wildly in their input and output parameters, or so I’m told).

Ransomware attacks as n-person prisoner’s dilemmas

Yesterday, I completed a marathon on the SkiErg, with a pretty respectable time (see results here). I know I can do better, and I know I
<em>
 will
</em>
do better. On the other hand, this was a marathon where I pretty much did everything wrong. And that was sort of an instructive experience in its own right. The title is somewhat misleading. Not much went wrong – the marathon itself was smooth sailing.

How to do a SkiErg marathon entirely the wrong way (but still finish)

I love posts that allow me to merge some of my addictions.

Auto-DOI for Quarto posts via Rogue Scholar

::: {.callout .callout-style-default .callout-tip .callout-titled}
::: {.callout-header .d-flex .align-content-center}
::: {.callout-icon-container}
:::

::: {.callout-title-container .flex-fill}
Tip
:::
:::

::: {.callout-body-container .callout-body}
If you're here for the DOI matching script, the link is
[here](https://github.com/chrisvoncsefalvay/chrisvoncsefalvay.github.io/blob/main/scripts/pre_doi_from_rogue_scholar.py).
:::
:::

[Quarto](https://quarto.org) is a great tool for reproducible research.
It is also a great tool for building websites. After about a decade of
Wordpress-based websites, I've moved to Quarto primarily for two
reasons. First, most of my content is largely static. I don't quite need
the full power of a CMS, and the performance cost of dynamic generation
I didn't need was quite steep (the economic cost was nothing special,
but I'm a cheapskate). Second, I wanted to be able to write in Markdown
and integrate better with notebooks. Quarto lets me do both of these.

What Quarto also does, however, is something super awesome: project
scripts!

::: {#project-whats .section .level1}
# Project whats?

A project script in Quarto is, basically, [a piece of Python, Lua, R or
Typescript code that is executed at some point during
rendering](https://quarto.org/docs/projects/scripts.html). This is super
useful, because it allows you to do things like, say, automatically
generate a list of publications from a BibTeX file -- which is among
others what I'm using it for. Essentially any programmatic function can
be implemented in a project script.

::: {.cell layout-align="center"}
::: {.cell-output-display}
::: {#fig-pipeline .quarto-figure .quarto-figure-center .anchored}
<figure class="figure">
<div>
<pre class="mermaid mermaid-js" data-label="fig-pipeline"><code>flowchart TD
    A[Rendering pipeline start] --&gt; B(Pre-render scripts)
    B --&gt; C(Page rendering)
    C --&gt; D(Post-render scripts)
    D --&gt; E[Rendering pipeline end]</code></pre>
</div>
<figcaption>Figure 1: Rendering pipeline in Quarto with pre- and
post-render scripts.</figcaption>
</figure>
:::
:::
:::

Quarto distinguishes between pre-render and post-render scripts. No
prizes for guessing the difference, but here it goes: pre-render scripts
are executed before the page is rendered, and post-render scripts are
executed after the page is rendered. Pre-render scripts are particularly
useful as they can modify the source `.qmd` (Quarto markdown) files
before rendering them to HTML or whatever their ultimate evolutionary
destiny is.

To make project scripts work, you need to declare them in your
`_quarto.yml` file:

::: {#cb1 .sourceCode style="background: #f1f3f5;"}
``` {.sourceCode .yaml .code-with-copy}
project:
  type: website
  pre-render:
    - scripts/pre_create_papers_file.py
    - scripts/pre_check_skierg_records.py
```
:::

This declares the scripts `scripts/pre_create_papers_file.py` and
`scripts/pre_check_skierg_records.py` as pre-render scripts. You can
also declare post-render scripts, with the `post-render` key.
:::

::: {#a-poorly-worked-example-generating-a-publication-list .section .level1 .page-columns .page-full}
# A (poorly) worked example: generating a publication list

::: {.page-columns .page-full}
On my website, I use Quarto project scripts to maintain a [list of my
papers](papers). This list is generated from a BibTeX file, which makes
it a little more convenient to maintain my publications, and somewhat
future-proofed in case I want a different format.^1^

::: {.no-row-height .column-margin .column-container}
^1^ I know there's a canonically better solution that uses pandoc and
Lua. I don't care. This works for me, and I don't have to learn Lua.
:::
:::

You can see the full project script
[here](https://github.com/chrisvoncsefalvay/chrisvoncsefalvay.github.io/blob/main/scripts/pre_create_papers_file.py),
but here's the gist of it:

::: {.cell layout-align="center"}
::: {.cell-output-display}
::: {#fig-bibliography .quarto-figure .quarto-figure-center .anchored}
<figure class="figure">
<div>
<pre class="mermaid mermaid-js" data-label="fig-bibliography"><code>flowchart TD
    A[BibTeX file] --&gt; a(&quot;load_bibtex_file()&quot;) 
    a --&gt; B[BibTeX database object]
    B --&gt; b(&quot;render_as_nlm()&quot;) 
    b --&gt; C{book or article?}
    C --&gt; D[article]
    C --&gt; E[book]
    D --&gt; d(&quot;render_article_as_nlm()&quot;) 
    d --&gt; F[article entry]
    E --&gt; e(&quot;render_book_as_nlm()&quot;) 
    e --&gt; G[book entry]
    F --&gt; H[all entries]
    G --&gt; H
    H --&gt; h(&quot;generate_list_by_year()&quot;) 
    h --&gt; J[final set of entries]
    J --&gt; j(&quot;write_into_file()&quot;) 
    j --&gt; K[&quot;papers/index.qmd&quot;]</code></pre>
</div>
<figcaption>Figure 2: My super clumsy pre-render script to build my
bibliography.</figcaption>
</figure>
:::
:::
:::

We load a BibTeX file (`load_bibtex_file()`), parse it, use a function
to determine whether we're rendering a book or an article entry (I don'
have any other types of publications, but if I did, I'd add them here),
and dispatch rendering to the appropriate function
(`render_article_as_nlm()` for articles, `render_book_as_nlm()` for
books). We sort the entries into a Markdown format with years separated
by level 1 headings (`generate_list_by_year()`) and finally write it
into the `papers/index.qmd` file (`write_into_file()`). There's some
minor magic going on behind the scenes, such as capturing my name and
setting it in bold (which is a bit of a convention in academic lists of
publications), but that's the gist of it.

The result is a list of publications that is automatically generated
from a BibTeX file, and is always up to date (as up to date as the
BibTeX file, anyway). I don't have to manually update it... sort of.
:::

::: {#wait-automagically-updated .section .level1 .page-columns .page-full}
# Wait, automagically updated?

The second half of what makes project scripts awesome is that they
integrate with the rendering process. If the rendering process in turn
integrates with some CI that watches for changes, then you can have a
website that is automatically updated whenever you push a change to the
repository. This is what I do with my website: I have a GitHub action
that watches for changes to the `main` branch, and if it detects a
change, it runs the rendering process and pushes the result to the
`gh-pages` branch. This means that if I were to change the BibTeX file,
it would trigger a re-render, and the list of publications would be
automatically updated.

There are some tricks to keep in mind here. Most importantly, because
this requires some custom Python packages, I had to slightly amend my
Github publishing workflow:

::: {.cell layout-align="center"}
::: {.cell-output-display}
::: {#fig-ci-cd .quarto-figure .quarto-figure-center .anchored}
<figure class="figure">
<div>
<pre class="mermaid mermaid-js" data-label="fig-ci-cd"><code>flowchart TD
    A[&quot;actions/checkout@v4&quot;] --&gt; B[&quot;quarto-dev/quarto-actions/setup@v2&quot;]
    B --&gt; C[&quot;actions/setup-python@v4&quot;]
    C --&gt; D(&quot;pip install -r requirements.txt&quot;)
    D --&gt; E[&quot;quarto-dev/quarto-actions/publish@v2&quot;]
    style D stroke-width:8px;
    style C stroke-width:8px;</code></pre>
</div>
<figcaption>Figure 3: Integrating the pre-render script into the Github
Actions CI/CD framework. The parts that need to be integrated into the
publishing workflow are highlighted with bold outlines.</figcaption>
</figure>
:::
:::
:::

In particular, I had to explicitly specify the Python version and
install the requirements. This is because the `quarto-actions/setup`
action does not install the requirements, and the
`quarto-actions/publish` action does not install Python. This is
admittedly a bit of a nuisance to work around, but really not all that
big a deal in the grand scheme of things.

::: {.page-columns .page-full}
One thing to keep in mind when writing your script is the context from
which it will be executed. In particular, if you're using a CI/CD
pipeline, you will need to make sure that the script can find the files
it needs. In my case, I had to explicitly specify the path to the BibTeX
file, as well as the path to the output file. This is because the script
is executed from the root of the repository, but the BibTeX file is in
the `papers` directory, and the output file is in the `papers`
directory, too. Testing locally for deployment in CI/CD is notoriously
hellish, but with a little bit of elbow grease,^2^ you can get it to
work.

::: {.no-row-height .column-margin .column-container}
^2^ And by 'a little bit', I mean absolute tons of it.
:::
:::

One caveat: rendering with pre- and post-render project scripts may be
relatively expensive in terms of time. My silly SkiErg world record
script adds a good 20-25 seconds of processing time to each rendering
run -- not a lot, but it does stack up eventually. The
[documentation](https://quarto.org/docs/projects/scripts.html) helpfully
discloses that Quarto provides an environment variable,
`QUARTO_PROJECT_RENDER_ALL`, which is set to `1` if it's a full render.
It may make sense to do a more manual caching here.
:::

::: {#things-you-can-do-with-project-scripts .section .level1}
# Things you can do with project scripts

Seriously, the possibilities of what you can do with project scripts are
pretty much endless. I have a project script that [checks the world
records list on the official SkiErg website and makes sure my index page
lists my accurate
records](https://github.com/chrisvoncsefalvay/chrisvoncsefalvay.github.io/blob/main/scripts/pre_check_skierg_records.py).
This is completely silly, but it's also a great example of how you can
use project scripts to automate just about everything:

- [A script I
  built](https://github.com/chrisvoncsefalvay/chrisvoncsefalvay.github.io/blob/main/scripts/pre_doi_from_rogue_scholar.py)
  pulls DOIs minted by [Rogue Scholar](https://rogue-scholar.org) and
  appends them to posts.
- A lot of projects use it for housekeeping: [via
  makefiles](https://github.com/CSCAR/workshop-stata-intro/blob/main/Makefile)
- The [bambi](https://github.com/bambinos/bambi) project uses it to
  [build a
  changelog](https://github.com/bambinos/bambi/blob/main/docs/pre_render.py),
  which is a great idea for applications that do need it
- This one cool master's thesis uses pre-render project scripts to [load
  variables from a YAML file into
  envvars](https://github.com/danielvartan/mastersthesis/blob/bebb699af7cab7add37a33768ccd605a60a18ba8/R/quarto-pre-render-html.R#L82),
  and I've [seen the same done with Rprofile
  files](https://github.com/computorg/computo-quarto-extension/blob/main/prerender.R)
  -- obviously, these are much more pertinent to projects where the bulk
  of the project consists of notebooks/code execution rather than
  websites, but again, the idea is the same
- Obviously, I'm not the only one to use it for [reference
  management](https://github.com/nfrerebeau/rarcheo/blob/master/_references.R)
- You can use it to [download static content into your
  project](https://github.com/lnnrtwttkhn/version-control-book/blob/main/Makefile),
  too!

The sky's the limit! I'm currently working on rendering my CV from a
JSON file via a project script, as well as a few other cool things. I
keep my project scripts
[here](https://github.com/chrisvoncsefalvay/chrisvoncsefalvay.github.io/tree/main/scripts)
-- I hope they will inspire you to do something cool with your own
project scripts!
:::

::: {#quarto-appendix .default}
::: {.section .quarto-appendix-contents}
## Citation {#citation .anchored .quarto-appendix-heading}

<div>

::: {.quarto-appendix-secondary-label}
BibTeX citation:
:::

``` {.sourceCode .code-with-copy .quarto-appendix-bibtex}
@misc{csefalvay2023,
  author = {Chris von Csefalvay},
  title = {Quarto Project Scripts Are Awesomeness},
  date = {2023-10-22},
  url = {https://chrisvoncsefalvay.com/posts/quarto-project-scripts},
  doi = {10.59350/b4qyq-70w75},
  langid = {en-GB}
}
```

::: {.quarto-appendix-secondary-label}
For attribution, please cite this work as:
:::

::: {#ref-csefalvay2023 .csl-entry .quarto-appendix-citeas}
Chris von Csefalvay. 2023. "Quarto Project Scripts Are Awesomeness."
<https://doi.org/10.59350/b4qyq-70w75>.
:::

</div>
:::
:::
