Trying to find useful things to do with emerging technologies in open education and data journalism. Snarky and sweary to anyone who emails to offer me content for the site.
The original MyBinder service for launching Jupyter notebooks from GitHub originally included an option to attach a PostgreSQL database that you could access from Jupyter notebooks:
With JupyterLite taking over many of the demo requests for the Try Jupyter site from MyBinder, reducing the need for anything other than a simple webserver on the Try Jupyter site, and Jupyterlab running purely in the browser under WASM, I wonder whether it would be possible to integrate an in-browser PostgreSQL server into the distribution using postgres-wasm (earlier review)?
I also note that Jupyter (originally coined from Julia, Python and R, with the suggestion, if not implication, that the environment would support those separate languages equally) is now a step closer to being legitimised again with a blog post from the Posit (RStudio, as was) camp, who very sensibly got George Stagg on board and supported his development of WebR, that announced the official release last week of WebR, and with it an experimental JupyerLite R kernel. There’s a list of WebR/wasm compiled supported R packages here.
Presumably, that means you’ll also be able to use the JupyterLite R kernel to provide in-browser code execution in a Thebe (ThebeLite?) backed Jupyter Book when that package gets a release (it keeps seeming to be so close…! Maybe for JupyterCon?)
Hmm… now I wonder… There was a xeus-sqlite Jupyterlite kernel, presumably derived from the xeus-sql kernel? So I wonder – could you get a xeus-sql kernel running in JupyterLite and calling postgres-wasm running in the same tab?
I also wonder: what if Jupyter Book could transclude content from a wasm flavoured SQLite or PostgreSQL database? Or ship a full-text, fuzzy, or even semantic search using a wasm powered database?
PS in passing, I also note various WASM backed dashboarding solutions:
Shiny Live (Pyodide backed Shiny dashboards; it also looks like we might expectShiny Live R dashboards at some point?);
stlite (“Serverless Streamlit, a port of Streamlit to WebAssembly, powered by Pyodide“).
Again, it’d be interesting to see one of those shipping with database hooks in place? Or DuckDB integration so you could easily make SQL requests over various a whole host of sources. Or datasesette-lite? Etc etc. (I’m not sure how the plumbing would work though???)
So I started wondering about a complement, “This is Not Me”, that could link to customisable AI tools that could take over you, for example, by generating things in the style of you.
VALL-E (research paper on a text-to-speech generator using your voice, from a short clip of you speaking);
FRAN (“Production-Ready Face Re-Aging for Visual Effects” from Disney);
Calligrapher AI (text-to-handwriting: parameterised, at the moment, but how long before you can train it with your handwriting?)
Things to look out for:
did you really go there? (add your photo to an obscure location; photoshop does this already, but 1-click for the rest of us…);
did you really do that? (photo of you apparently doing something — trampolining whilst wearing wellies and a Rocky Horror costime, for example; okay… maybe you did do that… Again, Photoshop, but for the rest of us…)
did you really write that? (something written in your style and with your flavour of typos.. I suspect there are lots of these already but I haven’t looked…)
Getting darker, then there’s the deepfake pr0n stuff, of course…
Various other bits related:
Runway — “Inpaint Content Aware Fill: Remove Objects From Video”
OpenAI announce the release of an AI generated text identification tool that they admit is broken (“not fully reliable”, as they euphemistically describe it) and that you have figure out how to use as best you can, given its unreliability.
Even though we spend 2-3 years producing new courses, the first presentation always has broken bits, broken bits that sometimes take years to be discovered, others that are discovered quickly but still take years before any one gets round to fixing them. Sometimes, courses need a lot of work after the first presentation reveals major issues with them. Updates to materials are discouraged, in case they are themselves broken or break things in turn, which means materials start to rot in place (modules can remain in place for 5 years, even 10, with few changes).
My attitude has been that we can ship things that are a bit broken, if we fix them quickly, and/or actively engage with students to mitigate or even explore the issue. We just need to be open. Quality improved through iteration. Quality assured through rapid response (not least becuase the higher the quality at the start, the less work we make for ourselves by having to fix things).
Tinkering with ChatGPT, I started wondering about how we can co-opt ChatGPT as a teaching and learning tool, given its output may be broken. ChatGPT as an unreliable but well-intentioned tutor. Over the last week or two, I’ve been trying to produce a new “sample report” that models the sort of thing that we expect students to produce for their data analysis and management course end-of-course assessment (a process that made me realise how much technical brokenness we are probably letting slip through if the presented reports look plausible enough — the lesson of ChatGPT again comes to mind here, with the student submitting the report as being akin to an unreliable author who can slip all sorts of data management abuses and analysis mistakes through in a report, in a largely non-technical that only displays the results and doesn’t show the working). In so doing, I wondered whether it might be more useful to create an “unreliable” sample report, but annotate it with comments, as if from a tutor, that acknowledged good points and picked up on bad ones.
My original thinking seven or eight years ago now was that the final assessment report for the data management and analysis course would be presented as a reproducible document. That never happened — I had little role in designing the assessment, and things were not so mature getting on for a decade ago now when the cours was first mooted — but as tools like Jupyter Book and Quarto show, there are now tools in place that can produce good quality interactive HTML reports with hideable/revealable code, or easily produce two parallel MS Word or PDF document outputs – a “finished document” output (with code hidden), and a “fully worked” document with all the code showing. This would add a lot of work for the student though. Currently, the model we use is for students to work in a single project diary notebook (though some students occasionally use multiple notebooks) that contains all manner of horrors, and then paste things like charts and tables into the final report. The final report typically contains a quick discursive commentary where the students explain what they think they did. We reserve the right to review the code (the report is the thing that is assessed), but I suspect the notebook contents rarely get a detailed look from markers, even if they are looked at at all. For students to tease only the relevant code out of their notebook into a reproducible report would be a lot of extra work…
For the sample report, my gut feeling is that the originating notebook for the data handling and analysis should not be shared. We need to leave the students with some work to do, and for a technical course, that is the method. In this model, we give a sample unreproducible report, unreliable but commented upon, that hints at the sort of thing we expect to get back, but that hides the working. Currently, we assess the student’s report, which operates at the same level. But ideally, they’d give us a reproducible report back that gives us the chance to look at their working inline.
Anyway, that’s all an aside. The point of this post was an announcement I saw from OpenAI — New AI classifier for indicating AI-written text — where they claim to have “trained a classifier to distinguish between text written by a human and text written by AIs from a variety of providers“. Or not:
Our classifier is not fully reliable.[OpenAI’s emphasis] In our evaluations on a “challenge set” of English texts, our classifier correctly identifies 26% of AI-written text (true positives) as “likely AI-written,” while incorrectly labeling human-written text as AI-written 9% of the time (false positives).
OpenAI then make the following offer: [w]e’re making this classifier publicly available to get feedback on whether imperfect tools like this one are useful.
So I’m wondering: is this the new way of doing things? Giving up on the myth that things work properly, and instead accept that we have to work with tools that are known to be a bit broken? That we have to find ways of working with them that accommodate that? Accepting that everything we use is broken-when-shipped, that everything is unreliable, and that it is up to us to use our own craft, and come up with our own processes, in order to produce things that are up to the standard we expect, even given the unreliability of everything we have to work with? Quality assurance as an end user problem?
Over on the elearnspace blog, George — I’m assuming it’s George — makes the following observation in This Time is Different. Part 1.: “I’m writing a series on the threat higher education faces and why I think it’s future is one of substantive, dramatic, and systemic changes. However, it’s not AI. There are a range of factors related to the core of what educators do: discover, create, and share knowledge. AI is part of it – and in the future may be the entirety of it. Short term, however, there are other urgent factors.“
I’ve increasingly been thinking about the whole “discover, create, share” thing in a different context over the last year or so, in the context of traditional stroytelling.
I now spend much of my free-play screen time trawling the archive.org looking for 19th century folk tale and fairy tale collections, or searching dismally OCR’d 19th newspapers in the British newspapers archive (I would contribute my text corrections back, but in the British newspaper archive at least, the editor sucks and it would take forever; it’s not hard to imagine a karaoke display with that tries to highlight each word in turn to prompt you to read the text aloud, then use whisper.ai to tunr that into text, but as it is, you get arbitrarily chunked smally collections of words with their own edit box that take forever to update separately. The intention is obviously to improve the OCR training, not allow readers who who have transcribed the whole to paste some properly searchable text in and then let the machine have a go at text alignment.)
So for me, text related online discovery now largely relates to discovery within 19th century texts, creating is largely around trying to pull stories together, or sequences of stories that work together, and sharing is telling stories in folk clubs and storytelling gigs. As to sharing knowledge, the stories are, of course, all true…
I’ve also played with ChatGPT a little bit, and it’s a time waster for me. It’s a game as you try to refine the prompt to generate answers of substance, every claim of fact requires fact checking, and whilst the argumentation appears reasonable at a glance, it doesn’t always follow. The output is, on the surface, compelling and plausible, and is generated for you to read without you having to thing too much about it. I realise now whey Socratic dialogue as a mode of learning gets a hard press: the learner doesn’t really have to do much og the hard learning work, where you have to force your own brain circuits to generate sentences, and rewire those bits of your head that make you say things that don’t make sense, or spout ungrounded opinions, à la Chat je pétais.
Elsewhere, I note that I should probably be following Jackie Gerstein via my feeds…
Dave Cormier also shares a beuaifully rich observation to ponder upon — ChatGPT as “autotune for knowledge”. And Simon Willison shares a handy guide to improving fart prompts from the Open.ai Cookbook — Techniques to improve reliability — because any prompts you do use naively are just that.
I hate and resent digital technology more and more every day.
And though trying to sell tickets to oral culture events, I am starting to realise how many people are digitally excluded, don’t have ready internet access, can’t buy things online, and don’t discover things online. And I would rather spend my time in their world than this digital one. Giving up archive.org would be a shame, but I have no trouble finding books in second hand bookshops, even if they do cost a bit more.
When I write code, I typically co-opt functions and algorithms I’ve pinched from elsewhere.
There are Python packages out there that are likely to do pretty much whatever you want, at least as a first draft, so to my mind, it makes sense to use them, and file issues (and occasionally PRs) if they don’t quite do what I want or expect, or if I find they aren’t working as advertised or as intended. (I’m also one of those people who emails webmasters to tell them their website is broken…)
But I’m starting to realise that there’s now a whole other class of off-the-shelf computational building blocks available in the form of AI pipelines. (For example, I’ve been using the whisper speech2text model for some time via a Python package.)
For example, the Hugging Face huggingface/transformers package contains a whole raft of pre-trained AI models wrapped by simple, handy Python function calls.
For example, consider a “table question answering” task: how would I go about creating a simple application to help me ask natural language queries over a tabular data set? A peek at the Hugging Face table question answering task suggests using the table-question-answering transformer and the google/tapas-base-finetuned-wtq model:
from transformers import pipeline
import pandas as pd
# prepare table + question
data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
table = pd.DataFrame.from_dict(data)
question = "how many movies does Leonardo Di Caprio have?"
# pipeline model
# Note: you must to install torch-scatter first.
tqa = pipeline(task="table-question-answering", model="google/tapas-large-finetuned-wtq")
# result
print(tqa(table=table, query=query)['cells'][0])
#53
The task description also points to at least one application demonstrating the approach — Table Question Answering (TAPAS) — although when I tried I could only get it to give one column in reply on queries I posed to it…
…which is to say the the models / applications may not do quite what you want them to do. But as with a lot of found code, it can often help get you started, either with some code you can revise, or as an example of an approach that does not do what you want and that you should avoid.
Now I’m wondering: are there other transformers like packages out there? And should I be looking at getting myself a m/c with a reasonable GPU so I can run this stuff locally… Or bite the bullet and start paying for AI APIs and on-demand GPU servers…
The tools for prototyping ideas are SO GOOD right now. This afternoon, I made a “citations needed” bot for automatically adding citations to the stuff that ChatGPT makes up
Having spent a few minutes prior to that doing a “traditional” search using good old fashioned search terms and the Google scholar search engine to try to find out how defendants in English trials of the early 19th century could challenge jurors (Brown, R. Blake. “Challenges for Cause, Stand-Asides, and Peremptory Challenges in the Nineteenth Century.” Osgoode Hall Law Journal 38.3 (2000) : 453-494, http://digitalcommons.osgoode.yorku.ca/ohlj/vol38/iss3/3 looks relevant), I wondered whether ChatGPT, and a John Lam’s search assist, might have been able to support the process:
Firstly, can ChatGPT help answer the question directly?
Secondly, can ChatGPT provide some search queries to help track down references?
The original rationale for the JSON based response was so that this could be used as part of an automated citation generator.
So this gives us a pattern of: write a prompt, get a response, request search queries relating to key points in response.
The recipe begins with a semantic search of a set of papers. This is done by generating an embdding for the documents you want to search over using the OpenAI embeddings API, though we could roll our own that runs locally, albeit with a smaller model. (For example, here’s a recipe for a simple doc2vec powered semantic search.) To perform a semantic search, you find the embedding of the search query and then find near embeddings generated from your source documents to provide the results. To speed up this part of the process in datasette, Simon created the datasette-faiss plugin to use FAISS .
The content of the discovered documents are then used to seed a ChatGPT prompt with some “context”, and the question is applied to that context. So the recipe is something like: use a query to find some relavant documents, grab the content of those documents as context, then create a ChatGPT prompt of the form “given {context}, and this question: {question}”.
It shouldn’t be too difficult to hack together a think that runs this pattern against OU-XML materials. In other words:
generate simple text docs from OU-XML (I have scrappy recipes for this already);
build a semantic search engine around those docs (useful anyway, and I can reuse my doc2vec thing);
build a chatgpt query around a contextualised query, where the context is pulled from the semantic search results. (I wonder, has anyone built a chatgpt like thing around an opensource gpt2 model?)
PS another source of data / facts are data tables. There are various packages out there that claim to provide natural language query support for interrogating tabular data eg abhijithneilabraham/tableQA, and this review article, or the Higging Face table-question-answering transformer, but I forget which I’ve played with. Maybe I should write a new RallyDataJunkie unbook that demonstrates those sort of tool around tabulated rally results data?
Pondering various ways in which tools can be used to help students improve the quality of their sumitted assessment materials, from spell-checking, to grammar checking, to automated code formatting tools, code quality tools, code suggestion/completion tools (from simple name completion to Github Co-Pilot code generation), maths engines (Mathematica, Wolfram Alpha etc), to getting someone else to read over your submission to make sure it makes sense, to working independently but conversationally with a study buddy or tutor, to conversations with AI models, to generating complete draft texts with AI models (ChatGPT etc), to pasting questions on cheat sites and copying the suggested answers, to paying someone to do an assessment for you.
If I were a “qualified” educator, I would probably be able to reel off various taxonomies that distinguish between various forms of “cheating”, but as I donlt recall any offhand, I’ll “cheat”:
More “cheating”…
And even more “cheating”…
If I were formally reporting this, I’d probably use a table. Time to “cheat” again…
Using such taxonomies, we can start to talk about them separately and preclude students from using different approaches in different contexts, or, conversely, allowing, encouraging or requiring their use, perhaps in an assessment that also requires the sudent to demonstrate process.
My late New Year resolution will be to refine how I talk about things like ChatGPT in an education context, and regard them primarily as machine assist tools. I can then separately consider about how and why it might be appropriately used in teaching, learning and assessment, and how we might then try to justify excluding its use for particular assessments. How we might detect such use, if we have tried to exclude it, is another matter.
There’s a lot of not much substance that’s been written recently about the threat posed to education (and, in particular, assessment) by ChatGPT and it’s ilk. The typical starting point is that ChatGPT can (rather than could) be used as a universal cheating engine (CheatGPT?), therefore everyone will use it to cheat.
In the course I work on, the following statement defines the assessment contract we have with students:
PLAGIARISM WARNING – the use of assessment helpservices and websites
The work that you submit for any assessment/exam on any module should be your own. Submitting work produced by or with another person, or a web service or an automated system, as if it is your own is cheating. It is strictly forbidden by the University.
You should not:
provide any assessment question to a website, online service, social media platform or any individual or organisation, as this is an infringement of copyright.
request answers or solutions to an assessment question on any website, via an online service or social media platform, or from any individual or organisation.
use an automated system (other than one prescribed by the module) to obtain answers or solutions to an assessment question and submit the output as your own work.
discuss exam questions with any other person, including your tutor.
The University actively monitors websites, online services and social media platforms for answers and solutions to assessment questions, and for assessment questions posted by students. Work submitted by students for assessment is also monitored for plagiarism.
A student who is found to have posted a question or answer to a website, online service or social media platform and/or to have used any resulting, or otherwise obtained, output as if it is their own work has committed a disciplinary offence under Section SD 1.2 of our Code of Practice for Student Discipline. This means the academic reputation and integrity of the University has been undermined.
The Open University’s Plagiarism policy defines plagiarism in part as:
using text obtained from assignment writing sites, organisations or private individuals.
obtaining work from other sources and submitting it as your own.
If it is found that you have used the services of a website, online service or social media platform, or that you have otherwise obtained the work you submit from another person, this is considered serious academic misconduct and you will be referred to the Central Disciplinary Committee for investigation.
It is not uncommon in various assessment questions to see assessment components that either implicitly or explicitly provide instructions of the form using a web search engine to prompt students to research a particular question. Ordinarily, this might count as “using an automated system”, although its use is then legitimised by virtue of being ” prescribed by the module”).
I haven’t checked to see whether the use of spell checkers, grammar checkers, code linters, code stylers, code error checkers, etc. are also whitelisted somewhere. For convenience, let’s call these Type 1 tools.
In the same way that we can specify “presentation marks” in a marking guide that can be dropped to penalise misspelled answers, code linters can be used to warn about code style that deviates from a particular style guide convention. In addition, code formatter tools can also automatically correct deviations from style guides (the code isn’t changed, just how it looks).
If we install and enable these “automatic code style correction” tools, we can ensure that students provide style conforming code, but at the risk they don’t actually learn the rules or how to apply them, they just let the machine do it. Does that matter? On the other hand, we can configure the tools to display warnings about code style breaches, and prompt the student to manually correct the code. Or we can provide a button that will automatically correct the code style, but the student has to manually invoke it (ideally afer having read the warning, the intention being that at some point they start to write well-styled code without the frictional overhead of seeing warnings then automatically fixing the code).
There are other tools available in coding contexts that can be used to check code quality. For example, checking whether all required packages are imported, checking that no packages are loaded that aren’t used, or functions defined but not called, or variables assigned but not otherwise referred to. (We could argue these are “just” style breaches of a style rule that says “if something isn’t otherwise referred to, it shouldn’t be declared”.) Other rules might explicitly suggest code rewrites to improve code quality (for example, adamchainz/flake8-comprehensions or MartinThoma/flake8-simplify). Students could easily use such tools to improve their code, so should we be encouraging them to do so? (There is a phrase in many code projects that the project is “opinionated”; which is to say, the code maintainers have an opinion about how the code should be written, and often then include tools to check code conforms to corresponding rules, as well as making autocorrected code suggestions where rules are breached). When teaching coding, to what extent could, or should, we: a) take an opinionated view on “good code”; b) teach to that sandard; c) provide tools that identify contraventions against that standard as warnings; d) offer autocorrect suggestions? Which is to say, how much should we automate the student’s answering of a code question?
In many coding environments, tools are available that offer “tab autocompletion”:
Is that cheating?
If we don’t know what a function is, or what arguments to call it with, there may be easy ways of prompting for the documentation:
Is that cheating?
Using tools such as Github CoPilot (a code equivalent of ChatGPT), we can get autosuggestions for code that will perform a prompted for task. For example, in VS Code with the Github Copilot extension enabled (Github Copilot is a commercial service, but you can get free access as an educator or asna student) write a comment line describes what task you want to perform, then in the next line hit ctrl-Return to get suggested code prompts.
Is that cheating?
Using a tool such as Github Copilot, you get the feeling that there are three ways it can be used: as a simple autosuggestion tool, (suggesting the methods available on an object, for example), as a “rich autcompletion tool” where it will suggest a chunk of code that you can accept or not (as in the following screenshot), or as a generator of multiple options which you may choose to accept or not, or use as inspiration (as in the screenshot above).
In the case of using Copilot to generate suggestions, the user must evaluate the provided options and then select (or not) one that is appropriate. This is not so different to searching on a site such as Stack Overflow and skimming answers until you see somehting that looks like the code you need to perform a particular task.
Is using Stack Overflow cheating, compared to simply referring to code documentation?
In its most basic form, code documentation simply describes available functions, and how to call them (example):
But increasingly, code documentation sites also include vignettes or examples of how to perform particular tasks (example).
So is Stack Overflow anything other than a form of extended community documentation, albeit unofficial? (Is it unofficial if a package maintainer answers the Stack Overflow question, and then considers adding that example to the official documentation?)
Is Github Copilot doing anyhing more than offering suggested responses to a “search prompt”, albeit generated repsonses?
“To avoid ChatGPT being used for cheating, there are a few different steps that educators and institutions could take. For example, they could:
Educate students and educators on the ethical use of AI technology, including ChatGPT, in academic settings.
Develop guidelines and policies for the use of ChatGPT in academic work, and make sure that students and educators are aware of and follow these guidelines.
Monitor the use of ChatGPT in academic settings and take appropriate action if it is used for cheating or other unethical purposes.
Use ChatGPT in ways that support learning and academic achievement rather than as a replacement for traditional forms of assessment. For example, ChatGPT could provide personalized feedback and support to students rather than as a tool for generating entire papers or exams.
Incorporate critical thinking and ethical reasoning into the curriculum, to help students develop the skills and habits necessary to use ChatGPT and other AI technology responsibly.”
In my own use of ChatGPT, I have found it is possible to get ChatGPT to “just” generate responses to a question that may or may not be useful. Just like it’s possible to return search results from a web search engine from a search query or search prompt. But in the same way that you can often improve the “quality” of search results in a web search engine by running a query, seeing the answers, refining or tuning your own understanding of what you are looking for based on the search results, updating the query, evaluating the new search results, so too does iterating on, or building on from in conversational style, a prompt in ChatGPT (or Github Copilot).
Just as it might be acceptable for a student to search the web, as well as their course materials, set texts, or other academic texts they have independently found or that have been recommended to them by tutors or subject librarians, to support them in performing an assessment activity, but not acceptable to just copy and paste the result into an assessment document, it would also seem reasonable to let students interact with tools such as ChatGPT to help them come to an understanding of a topic or how to solve a particular problem, but in a “but don’t tell me the answer” sort of a way. The reward for the student should not be an extrinsic reward in the form of a mark, but the intrinsic reward of having answered the question themself: “I did that.” Albeit with a lot of tutor (or ChatGPT) help.
The issue is not so much around “[e]ducating students and educators on the ethical use of AI technology, including ChatGPT, in academic settings”, it’s around educating students on what the point of assessment is: to provide some sort of levelling feedback on how well they understand a particular topic or can perform a particular task based on their performance on a contrived activity and according to a particular evaluation scheme.
If we tweaked our assessment model to an open assessment, auction based variant that combines peer assessment and self-assessment, in which students are given assessments for their marks, then choose their own anticipated grade, then get to see everyone else’s script and personal anticipated grade, then get to revise their grade, then get randomly vivaed at a rate dependent on rank (highest ranking are more likely to be vivaed), would we be any worse off? Would we even need the initial step where a marker marks their scripts? Could we replace the viva with actual marking of a script. And let the Hunger Games begin as students crib between themselves how to score their work?
I have no idea if the proof is correct, but I thought the inclusion of the diagram script was interesting (I originally asked the question with the intenstion of seeing whether the proof was provided as a LaTeX script, with the idea that I would then also ask for a diagram to help make sense of the proof…)
Can you provide me with a proof, and explanation of each step, pf pythagoras’ theorem?
Me to ChatGPT
The code is Asymptote/LaTeX code. The ChatGPT UI does not render diagrams (though in many cases it probably could, e.g. using Javascript packages or an embedded WASM powered renderer), but we can find previewers online (eg http://asymptote.ualberta.ca/ ) to view the result:
[See later in the document how I tried to get ChatGPT to improve on the generated Asymptote diagrams.]
Now back to the proof:
Again, we can preview the diagram:
The proof then concludes:
What are the [asy] bits in your explanation?
Me to ChatGPT
That is very useful, but I tend to use Python and matplotlib for diagrams.
Me to ChatGPT
Again, the ChatGPT UI doesnlt embed Pyodide WASM and an embedded output display (though it could), bu we can preview the code elsewhere (eg using JupyterLite):
That Python chart includes a frame and axes around the triangle and the edges are not directly labeled. Ideally, I would just see a triangle with labeled sides.
Me to ChatGPT
Executing the code elsewhere again:
The labels are not very clear. The b and c labels should be midway along the corresponding side
Me to ChatGPT
And this gives:
You are wrong. The a and c labels are applied to the same side when I render that example. The xytext values for those labels are the same, which means the labels are printed at the same location, rather than being applied to separate sides.
Me to ChatGPT
Which gives:
That is still wrong. the c label is now near a vertex, not the midpoint of the hypotenuse, if indeed it does apply to the hypotenuse?
Me to ChatGPT
The c label is still too high. It should be closer to the edge (lower down the plot). What parameter do I need to change to manually fix your code myself?
Me to ChatGPT
I then returned to the Asymptote code…
Thank you. With your asymptote code, I notice the labels are very large compared to the triangle and the diagram is a mess. I’m not even sure if the labels are in the correct location. How could that be fixed?
Me to ChatGPT
This re-renders the second diagram as follows:
In you revised asymptote code, the h and a labels obscure each other. Also, your points A and D are at the same location. Also, not all vertices are labeled?
Me to ChatGPT
The location of h is now easier read but is meaningless? If h refers to a height, should it perhaps label a new vertical line that is distinguished in some way (eg a dashed line or a two ended arrow) that denotes a distance measurement?
Me to ChatGTP
Which gives:
The dashed line is occluded by a solid line drawn connecting A and C (which is the same as D and C, because A and D are the same point). it would be useful to be able to see a dashed line representing the height distinctly, perhaps by drawing it slightly to the side?
Me to ChatGPT
Which messes things up a little:
I left it there…
Form this interaction, as with many previous ones (including other chats to co-create diagrams), the human user needs to act as a critic, editor and co-creator. In many cases, the (commented, especially if prompted to add comments, or explained, if you ask for an explanation) diagram descriptions that ChatGPT drafts are often good enough to get you started, and require only slight fixes. It can sometimes be a real challenge to find a prompt to get ChatGPT to fix the issue, and easier to just do it yourself. Which suggests that if you want to document a process, an interactive notebook style UI may be more attractive, becuase along with capturing your own notes and prompts and the ChatGPT reponses and rendered previews, you will also be able to include your own revised code (and add that to the prompt history). I’ve yet to try the jflam/chat-gpt-jupyter-extension or TiesdeKok/chat-gpt-jupyter-extension extensions (and there may be others…; eg Fernando Perez’s quick magic hack, fperez/jupytee) that bring conversational ChatGPT style ish-magic to Jupyter notebooks, but it’ll be really interesting to see how it feels and what sort of transcripts result from using them.
I’ve been wonderig about the extent to which we can feed (small) texts into ChatGPT as part of a conversation and then get it to answer questions based on the text.
I’ve not really had a chanc to play with this yet, so this post is a placeholder/reminder/note to self as much as anything.
As a quick starting point, here’s an example of asking questions about family relationships based on a short provided text:
OUseful.Info, the blog... 