Io, ChatGPT e julia

Riassunto della puntata precedente che trovate nel post "Io, ChatGPT e Lorenza": stimolato da qualche domanda, chiedo a ChatGPT di risolvere un esercizio semplice da compito. Il celebre programma di Intelligenza Artificiale lo risolve in un attimo, spiegando pure i passaggi con sicumera, ma è tutto sbagliato e ChatGPT non si ravvede nemmeno quando provo ad aiutarlo... bocciato senza appello!

Non so nulla di julia, un linguaggio di programmazione che ha il nome della mia criminologa preferita e di cui sento dire meraviglie, con tanto di commenti sul web e discorsi di amici che si spingono a dire che sarebbe ottimo anche per scrivere modelli ad agenti. Eppure, vista la desolante performance di un tentativo di ChatGPT di risolvere l'equazione x^3+x+1=0, una roba standard e fattibile che uso in ogni compito tanto per scaldare i muscoli ai miei studenti, decido di partire da zero: ce la faccio con julia a trovare la soluzione, anche se non so nulla e non ho nemmeno il programma?

Sono le 13.26 e attacco con zio google per trovare l'installer, individuo subito vari siti molto ben fatti con quanto serve e parecchia documentazione. Scarico, doppio click e vedo sul terminal lo splash screen di benvenuto, a metà fra la preistoria dell'interfaccia testuale (che sempre sia lodata, per altro!) e la scelta accattivante dei colori. Due secondi e due righe dopo ho definito la mia funzione e tanto per gradire provo a vedere se tutto funziona con f(1), che produce 3, e f(-0.62)=0.141672, non lontano da zero. Chi ben comincia è già a metà dell'opera.

Altro giro per digitare la stringa di ricerca "solving equation julia" e "solving equation julia one variable", imbattendomi in una bella lista di pagine che spesso mi suggeriscono di utilizzare NLsolve o nlsolve. A dir la verità, leggendo due righe di esempio alla massima velocità, vedo che lo usano per risolvere sistemi di equazioni, anche troppa grazia visti che a me servirebbe qualcosa di più semplice, nella sola variabile x. Pesto sulla tastiera:

julia> using NLsolve

 │ Attempted to find missing packages in package registries but no registries are installed.

 └ Use package mode to install a registry. `pkg> registry add` will install the default registries.

ERROR: ArgumentError: Package NLsolve not found in current path.

- Run `import Pkg; Pkg.add("NLsolve")` to install the NLsolve package.

Stacktrace:

 [1] macro expansion

   @ ./loading.jl:1163 [inlined]

 [2] macro expansion

   @ ./lock.jl:223 [inlined]

 [3] require(into::Module, mod::Symbol)

   @ Base ./loading.jl:1144

julia> nlsolve(f,[-2,-1])

ERROR: UndefVarError: nlsolve not defined

Stacktrace:

 [1] top-level scope

 Mi rendo conto che devo installare qualcosa di aggiuntivo, NLsolve

 e poi potrò riprovare. Va bene, vai con import Pkg; Pkg.add("NLsolve"), non perdete nulla se scorrete velocemente il lungo elenco di passaggi seguenti, è solo per dare l'idea che julia ci mette impegno:

julia> import Pkg; Pkg.add("NLsolve")

  Installing known registries into `~/.julia`

    Updating registry at `~/.julia/registries/General.toml`

   Resolving package versions...

   Installed IrrationalConstants ── v0.2.2

   Installed DiffRules ──────────── v1.13.0

   Installed DiffResults ────────── v1.1.0

   Installed Adapt ──────────────── v3.6.1

   Installed Setfield ───────────── v1.1.1

   Installed NLsolve ────────────── v4.5.1

   Installed SpecialFunctions ───── v2.2.0

   Installed Preferences ────────── v1.4.0

   Installed NaNMath ────────────── v1.0.2

   Installed StaticArrays ───────── v1.5.24

   Installed StaticArraysCore ───── v1.4.0

   Installed OrderedCollections ─── v1.6.0

   Installed ConstructionBase ───── v1.5.2

   Installed SnoopPrecompile ────── v1.0.3

   Installed JLLWrappers ────────── v1.4.1

   Installed ChainRulesCore ─────── v1.15.7

   Installed NLSolversBase ──────── v7.8.3

   Installed Reexport ───────────── v1.2.2

   Installed Requires ───────────── v1.3.0

   Installed LogExpFunctions ────── v0.3.23

   Installed ArrayInterface ─────── v7.4.3

   Installed LineSearches ───────── v7.2.0

   Installed ForwardDiff ────────── v0.10.35

   Installed CommonSubexpressions ─ v0.3.0

   Installed MacroTools ─────────── v0.5.10

   Installed OpenSpecFun_jll ────── v0.5.5+0

   Installed StatsAPI ───────────── v1.6.0

   Installed UnPack ─────────────── v1.0.2

   Installed InverseFunctions ───── v0.1.9

   Installed Compat ─────────────── v4.6.1

   Installed Parameters ─────────── v0.12.3

   Installed Distances ──────────── v0.10.8

   Installed ChangesOfVariables ─── v0.1.7

   Installed FiniteDiff ─────────── v2.20.0

   Installed DocStringExtensions ── v0.9.3

  Downloaded artifact: OpenSpecFun

    Updating `~/.julia/environments/v1.8/Project.toml`

  [2774e3e8] + NLsolve v4.5.1

    Updating `~/.julia/environments/v1.8/Manifest.toml`

  [79e6a3ab] + Adapt v3.6.1

  [4fba245c] + ArrayInterface v7.4.3

  [d360d2e6] + ChainRulesCore v1.15.7

  [9e997f8a] + ChangesOfVariables v0.1.7

  [bbf7d656] + CommonSubexpressions v0.3.0

  [34da2185] + Compat v4.6.1

  [187b0558] + ConstructionBase v1.5.2

  [163ba53b] + DiffResults v1.1.0

  [b552c78f] + DiffRules v1.13.0

  [b4f34e82] + Distances v0.10.8

  [ffbed154] + DocStringExtensions v0.9.3

  [6a86dc24] + FiniteDiff v2.20.0

  [f6369f11] + ForwardDiff v0.10.35

  [3587e190] + InverseFunctions v0.1.9

  [92d709cd] + IrrationalConstants v0.2.2

  [692b3bcd] + JLLWrappers v1.4.1

  [d3d80556] + LineSearches v7.2.0

  [2ab3a3ac] + LogExpFunctions v0.3.23

  [1914dd2f] + MacroTools v0.5.10

  [d41bc354] + NLSolversBase v7.8.3

  [2774e3e8] + NLsolve v4.5.1

  [77ba4419] + NaNMath v1.0.2

  [bac558e1] + OrderedCollections v1.6.0

  [d96e819e] + Parameters v0.12.3

  [21216c6a] + Preferences v1.4.0

  [189a3867] + Reexport v1.2.2

  [ae029012] + Requires v1.3.0

  [efcf1570] + Setfield v1.1.1

  [66db9d55] + SnoopPrecompile v1.0.3

  [276daf66] + SpecialFunctions v2.2.0

  [90137ffa] + StaticArrays v1.5.24

  [1e83bf80] + StaticArraysCore v1.4.0

  [82ae8749] + StatsAPI v1.6.0

  [3a884ed6] + UnPack v1.0.2

  [efe28fd5] + OpenSpecFun_jll v0.5.5+0

  [0dad84c5] + ArgTools v1.1.1

  [56f22d72] + Artifacts

  [2a0f44e3] + Base64

  [ade2ca70] + Dates

  [8ba89e20] + Distributed

  [f43a241f] + Downloads v1.6.0

  [7b1f6079] + FileWatching

  [9fa8497b] + Future

  [b77e0a4c] + InteractiveUtils

  [b27032c2] + LibCURL v0.6.3

  [76f85450] + LibGit2

  [8f399da3] + Libdl

  [37e2e46d] + LinearAlgebra

  [56ddb016] + Logging

  [d6f4376e] + Markdown

  [ca575930] + NetworkOptions v1.2.0

  [44cfe95a] + Pkg v1.8.0

  [de0858da] + Printf

  [3fa0cd96] + REPL

  [9a3f8284] + Random

  [ea8e919c] + SHA v0.7.0

  [9e88b42a] + Serialization

  [6462fe0b] + Sockets

  [2f01184e] + SparseArrays

  [10745b16] + Statistics

  [4607b0f0] + SuiteSparse

  [fa267f1f] + TOML v1.0.0

  [a4e569a6] + Tar v1.10.1

  [8dfed614] + Test

  [cf7118a7] + UUIDs

  [4ec0a83e] + Unicode

  [e66e0078] + CompilerSupportLibraries_jll v1.0.1+0

  [deac9b47] + LibCURL_jll v7.84.0+0

  [29816b5a] + LibSSH2_jll v1.10.2+0

  [c8ffd9c3] + MbedTLS_jll v2.28.0+0

  [14a3606d] + MozillaCACerts_jll v2022.2.1

  [4536629a] + OpenBLAS_jll v0.3.20+0

  [05823500] + OpenLibm_jll v0.8.1+0

  [83775a58] + Zlib_jll v1.2.12+3

  [8e850b90] + libblastrampoline_jll v5.1.1+0

  [8e850ede] + nghttp2_jll v1.48.0+0

  [3f19e933] + p7zip_jll v17.4.0+0

Precompiling project...

  42 dependencies successfully precompiled in 42 seconds

Sembra aramaico ma julia, tutta da sola e senza errori, installa 42 pacchetti in 42 secondi, facendomi vedere con grazia lo stato di avanzamento a terminale. Adesso nlsolve ce l'ho e ci riprovo, ottenendo quel che vedete in figura. Non ci siamo ancora e la cosa ha molto senso, sto digitando cose a caso e già avevo capito che, probabilmente, stavo usando un macchinario enorme per risolvere una cosa semplice, proprio come quando ti metti in testa di usare la mitragliatrice contro le formiche.

Altro giro sui motori ma ormai sento il sapore del sangue, leggo in questa pagina che "NLsolve only solve vector problem AFAIK, but you can define a problem of size 1", c'è un esempio e capisco forte e chiaro come smanettarlo! 

Lo ammetto, non so (ancora) bene che cosa ho scritto e non capisco bene perché servano i due argomenti F e x ma si vede bene la sostanza: x^3+x+1

julia> function fun!(F, x)

                  F[1] = x[1]^3+x[1]+1

              end

fun! (generic function with 1 method)

Adesso non mi resta che dare il comando nlsolve(fun!, [0.1]), significa "risolvi", e si ottiene la soluzione -0.6823278047019576 che vedete in figura. Ci siamo, è la cosa giusta e sono le 13.41, da zero alla soluzione in 15 minuti (senza capire nulla seriamente, installando un po' a caso julia e i suoi pacchetti, senza alcun intoppo, ravanando un po' fino a quando ho trovato un esempio che potevo modificare). 15 minuti...

Questo episodio mi ha spinto a decidere di insegnare julia ai miei studenti l'anno prossimo, è ora di cambiare e di innovare rispetto a R, che è ed è stato un software meraviglioso. Ma il corso ha questa forma da una dozzina d'anni, a quel tempo R era la frontiera ed è ora di rimettersi in marcia. Lo devo ai miei neuroni in via d'invecchiamento, lo devo ai miei studenti che si possono mettere alla prova con quello che servirà nel prossimo decennio (e non col vecchiume di matlab, python and so on).

In fondo, la spinta me l'ha data ChatGPT e il suo clamoroso fiasco: tutti ne parlano ma l'intelligenza artificiale non è in grado di risolvere un problemino che si risolve in due righe di R e che io ho risolto in 15 minuti con uno strumento sconosciuto. Per qualche motivo questa esperienza (e lo scambio con Lorenza) mi hanno dato la carica. Sarà anche necessario capire la potenza e i difetti di un fenomeno come ChatGPT ma lo è di più vedere che altre cose sono affidabili, divertenti e formative, vai con julia!

Ma non è finita così. Una volta deciso di inserire in programma julia, di cui al momento non so una mazza, mi sono reso conto che mi devo documentare e cosa c'è di meglio che chiedere a ChatGPT? Specchio delle mie brame, puoi fornirmi le referenze più belle del reame?

ChatGPT, servizievolissimo, mi suggerisce tre referenze per imparare julia e i link ai pdf. Cappero, è proprio bravo, no?

(PDF link: https://benlauwens.github.io/ThinkJulia.jl/latest/book.pdf)

(PDF link: https://www.crcpress.com/downloads/K37868/Introducing_Julia.pdf)

(PDF link: https://github.com/JuliaComputing/JuliaBoxTutorials/blob/master/introductory-tutorials/numerical-computing-with-julia/numerical-computing-with-julia.pdf)

È una figata e m'ingolosisco, clicco sul primo indirizzo, ma il link è broken e non c'è nessun file. Poi clicco sul secondo link, broken pure lui... Indovinate cosa è successo quando ho provato a raggiungere il terzo link? Sì, ci avete beccato! Broken, page not found anche la terza volta! Tre su tre, mi hai preso per mona? Non è la prima volta che lo becco a dare referenze fantasiose, scritte secondo lui da gente che  sembra sensata, con titolo accattivante e tanto di indirizzo. Ma è tutto inventato o forse, decidete voi, completamente tarocco pur nella somiglianza superficiale con qualcosa che pare rilevante.

Ecco, ChatGPT è un portento ma non mettetevi nelle sue mani perché tutto quel che dice, quando si tratta di informazioni fattuali e non di discorsi vaghi, va verificato a sangue perché spesso fornisce informazioni del tutto inaffidabili. Per ora. Uomo avvisato mezzo salvato!

ps. I link su julia erano broken e "sbagliati" ma non sono stati del tutto inutili. Con un po' di pazienza, sono risalito a titolo e autore dei libri e ho anche ritrovato altrove alcuni dei file cui ChatGPT mi aveva indirizzato. A saperle usare anche informazioni imprecise possono essere utili, sono stati punti di partenza per il segugio  che è in me (è un altra versione di quanto dicevo prima: non sempre servono livelli di precisione atroce, spesso va bene un su-e-zo!).

ps2. Per chi ne vuol sapere di più (sono le stesse cose che sto leggendo o leggerò io):

• Ben Lauwens e Allen Downey hanno scritto questo libro-web "Think Julia: How to Think Like a Computer Scientist";
• La pagina https://github.com/mitmath/julia-mit è zeppa di bella roba, inlcuso il cheatsheet che mi sono già stampato;
• L'esempio vincente che ho usato per risolvere un'equazione in una variabile l'ho trovato qui;
• La pagina precedente menzionava anche Roots.jl e NonlinearSolve.jl. Studiando meglio le cose, si trovano metodi risolutivi più semplici ed efficaci di quello che ho usato io. Dopo aver guardato Roots.jl ho capito che bastava molto meno... 

julia> using Roots

 │ Package Roots not found, but a package named Roots is available from a

 │ registry. 

 │ Install package?

 │   (@v1.8) pkg> add Roots 

 └ (y/n/o) [y]: y

   Resolving package versions...

   Installed Roots ─────── v2.0.14

   Installed CommonSolve ─ v0.2.3

    Updating `~/.julia/environments/v1.8/Project.toml`

  [f2b01f46] + Roots v2.0.14

    Updating `~/.julia/environments/v1.8/Manifest.toml`

  [38540f10] + CommonSolve v0.2.3

  [f2b01f46] + Roots v2.0.14

Precompiling project...

  2 dependencies successfully precompiled in 8 seconds. 42 already precompiled.

julia> find_zero(f,0)

-0.6823278038280193

julia> f(x) = x^3+x+1

f (generic function with 1 method)

julia> find_zero(f,0)

-0.6823278038280193

julia> 

• Se siete appassionati di analisi numerica (che è dove "sono nato" io!), il libro di Giray Otken "First semester in numerical analysis with julia" è anche la scusa per imparare il linguaggio (se andate sulla pagina, cliccate sui pulsanti a ds per vedere o scaricare il pdf).

Io, ChatGPT e Lorenza

Secca come una fucilata: "Ma tu non hai paura che ChatGPT ti rubi il posto di lavoro?"

Sento una lievissima fitta agli addominali, è colpa evidentemente della panca bassa che abbiamo fatto stamattina a yoga, ma significa anche che la domanda mi ha fatto contrarre i muscoli. Giunge quasi alla fine di una conversazione interessante su ChatGPT, su come può cambiare lo scenario del lavoro, sui mestieri che si estingueranno e sulle professionalità che resteranno in sella a questo cavallo imbizzarrito e artificiale di cui tutto parlano. Respiro un attimo, ci penso su, un altro respiro e poi: "Lorenza, no, non credo che ci rimetterò il posto..." ChatGPT non è preciso, lo hanno beccato a contraddirsi molte volte, ma questo è tipico del linguaggio naturale, di come comunicano gli umani, tutto un ripetere cose lievemente diverse, infarcendo di contesto, di cose implicite e incerte, dando per scontato che l'interlocutore capisca e riempia i buchi del discorso. È ovvio, se ci pensate, che sui dettagli ci contraddiciamo spesso, non fosse altro perché tagliamo corto e non ripetiamo tutto quello che, forse, logicamente dovremmo. Tiriamo via dritto, e le scorciatoie possono tralasciare i dettagli, sono fatte apposta. La maggior parte delle nostre imprecisioni non è grave, aiuta la sintesi e nessuno te le rinfaccia (certo, ci sono anche i rompicoglioni...). I politici sono casi esemplari: cambiano idea sin verguenza come banderuole, dicono anche fesserie monumentali e poi si scusano, a base di "non mi avete capito", "non prendetemi alla lettera", "avete estrapolato dal contesto" (appunto, è semplre colpa del contesto!) e, per farla breve, li votiamo sempre nonostante le imprecisioni. "Ma io sono un matematico e la mia materia è una delle poche, pochissime, in cui la precisione estrema è l'essenza e la bellezza delle cose, non un'appendice cosmetica". E continuo dicendo che non ho paura di ChatGPT nemmeno nel mio secondo lavoro, quello di insegnante: "Non mi può sostituire perché educare significa tirare fuori dagli studenti quello che sono, serve capacità di coinvolgerli, di motivarli, di accendere un fuoco. Non si tratta solo di passare contenuti, ci vuole sempre un supplemento d'anima". ChatGPT non fa nulla di tutto questo, è uno zero nei confronti di un professore che ha letteralmente il potere di cambiarti la vita (se è bravo, d'accordo; ci sono anche quelli che ti fan venire il latte alle ginocchia!)

Eppure, la domanda m'inquieta. Lorenza scrive su un giornale locale, nella sua voce serpeggia curiosità, ammette di essere felice perché può scrivere di quel che le interessa (cosa rara, wow!) Fa le domande giuste, non cerca risposte semplici, memorizza la mia difficoltà a darle visioni e previsioni su quel che sarà, sorride all'altro lato della cornetta quando sparo che secondo me in 5 anni ChatGPT potrebbe avere già sostituito tutta una serie di lavoratori impegnati in mansioni intellettuali a bassa intensità, dato che altri intervistati le hanno detto che serviranno 10 o trent'anni.

La nostra bella conversazione finisce ma io continuo a mulinare cattivi pensieri: "ChatGPT, che diamine vuoi da me e dai miei studenti?", mi chiedo.  Decido di prendere un problema da compito, un esercizio standard per i miei studenti di "Computational tools", e di darlo in pasto all'AI: risolvi l'equazione x^3+x+1=0. A suo modo, non è un problema difficile, "x alla terza più x più uno uguale a 0", ma non c'è una formula risolutiva semplice come per le equazioni di secondo grado, quella che a un certo punto della vita abbiamo imparato tutti (sorvolo sul fatto che quanto ho scritto è un'imprecisione... Cardano abbi pietà ma non finirei più!)

Ogni computer dovrebbere risolvere quell'equazione di terzo grado "facilmente" e produrre il risultato. Vuoi vedere che da ora in poi i miei studenti mi possono fregare e trovare quel numero semplicemente chiedendo a ChatGPT?

solve the problem x^3+x+1=0

ChatGPT: Unfortunately, the equation x^3 + x + 1 = 0 does not have an algebraic solution that can be expressed in terms of elementary functions. This is because the equation is a cubic equation, and there is no general formula for solving cubic equations algebraically like there is for quadratic equations.

However, the equation can be solved numerically using numerical methods, such as the Newton-Raphson method or the bisection method. These methods involve iteratively refining an initial guess for the solution until it converges to the true solution.

Formulo il problema: risolvi un'equazione di terzo grado (8 maggio 2023)

È una bella filippica, fin qui tutto ok, ma non c'è ancora traccia della soluzione. Del numero, intendo.

Using the Newton-Raphson method, ... the solution to the equation x^3 + x + 1 = 0 is approximately -1.324717957244746.

Resto senza fiato! Sto gran figlio (o figlia?) dell'intelligenza artificiale e di un computer ha trovato la soluzione! E così potranno fare i miei studenti, senza studiare un solo minuto. Sono destinato alla disoccupazione, preparate anche per me il nuovo reddito di cittadinanza!

Non mi resta che dirmi "finché c'è vita c'è speranza" ma decido, per puro scrupolo, di controllare. Scrivo due righe in R, un altro programma di cui mi fido da decenni:

> f <- function(x) x^3+x+1

> uniroot(f,c(-2,0)) # trova la soluzione compresa fra -2 e 0

$root [1] -0.6823219

Vedo che la soluzione è -0.682. (sto arrontondando per risparmiarvi file di cifre). Ma ChatGPT aveva detto -1.325 e rotti... Un ghigno si scolpisce sulla mia faccia dato che ChatGPT, con grande faccia tosta, ha dato la soluzione sbagliata! Provo ad aiutarlo, se -1.325 fosse la soluzione dovrei ottenere che f(-1.325)=0.

compute f(x) with x= -1.324717957244746

ChatGPT: To compute f(x) with x = -1.324717957244746, we substitute this value of x into the function f(x) = x^3 + x + 1:

f(-1.324717957244746) = (-1.324717957244746)^3 + (-1.324717957244746) + 1

= -1.324717957244746

Therefore, f(-1.324717957244746) = -1.324717957244746.

Un altro pezzo di sessione (8 maggio 2023)

Ora, fidatevi, il ragionamento è giusto ma i conti sono tutti sbagliati e f(-1.324717957244746)=-2.649436. Riassumendo per i comuni mortali: ChatGPT sbaglia a trovare la soluzione e sbaglia pure a controllare se ha fatto giusto! Se fosse uno studente non se la passerebbe bene a questo punto. Provo a insistere, uso perfino un filo d'ironiaa, magari torna in sé:

that's strange as i got f(-1.324717957244746) = -2.649436

ChatGPT: I apologize for my mistake. You are correct.

To compute f(x) with x = -1.324717957244746, we substitute this value of x into the function f(x) = x^3 + x + 1:

f(-1.324717957244746) = (-1.324717957244746)^3 + (-1.324717957244746) + 1

= -2.64943585095

Ci sono segni di ravvedimento: intanto si scusa, come un Salvini qualsiasi dopo che ha detto una vaccata, vabbuò! Poi fa il conto giusto (ma il risultato gliel'avevo già detto io formulando la domanda), sempre meglio di nulla. Penso che forse ce la può fare e riattacco:

but you told me that f(-1.324717957244746)=0. can you try to solve the equation correctly?

ChatGPT si scusa un'altra volta e scrive questo sproloquio:

I apologize for the confusion and my previous incorrect answer. Here's an attempt to solve the equation x^3 + x + 1 = 0 using Cardano's method, which is a standard method for solving cubic equations:

First, we express the equation in the form x^3 = -x - 1:

x^3 = -(x + 1)

Next, we introduce a new variable y such that x = z - b/3, where b is the coefficient of the quadratic term, which is 0 in this case. This gives:

(z - b/3)^3 = -(z - b/3 + 1)

Expanding the left-hand side and simplifying, we get:

z^3 - 3bz^2/9 + 3b^2z/27 - b^3/27 = -z + 1/3

Multiplying both sides by 27 and simplifying, we obtain:

27z^3 - 27z + 9b^2z - b^3 + 3 = 0

Substituting b = 0, we get:

27z^3 - 27z + 3 = 0

Dividing both sides by 3, we obtain:

9z^3 - 9z + 1 = 0

Now, we need to find a root of this equation, which can be done using numerical methods such as the Newton-Raphson method. A root of this equation is approximately z = 0.4533976515.

Finally, we can obtain the three solutions of the original equation x^3 + x + 1 = 0 by using the formula x = z - b/3:

x1 = z - b/3 = 0.4533976515 - 0/3 = 0.4533976515 x2 = αz - β/3 = -1.088186771 - 0.5i x3 = αz - β/3 = -1.088186771 + 0.5i

where α = (-1 + sqrt(-3))/2 and β = (1 - sqrt(-3))/2 are the complex cube roots of unity.

Il punto è che  il valore z=0.4533976515 menzionato da ChatGTP, nuovamente, non è una soluzione! ChatGPT ci ha provato, e ha scritto una rampegada che contiene polvere di verità anche se, per notarlo, devi essere un matematico. Insomma, non è uno studente brillante ma ci ha provato, sbrodolando sia cose corrette che errori. Forse "ragiona" e prende dai siti alcune informazioni giuste ma poi o non le capisce o le usa male e, invitabilmente, produce il risultato sbagliato, questo povero z=0.453 che non c'entra con il numero giusto -0.682 (che R aveva trovato subito).

È ora di concludere: i miei studenti dovranno studiare ancora un po' o imparare altri trucchi dato che non si possono fidare di ChatGPT, che le spara grosse a raffica. Per ora nessuno mi ruberà la cattedra. Già, per ora: i sistemi di AI apprendono, si esercitano, a loro modo imparano dagli errori e forse proprio io, che pure l'ho preso per il culo, gli sto insegnando a risolvere le equazioni di terzo grado come si deve. E non è detto che, fra qualche settimana o mese, non riesca a darmi la risposta giusta con disinvoltura. Insomma, lo terrò sotto osservazione.

Continuo a pensare che su altri fronti ChatGPT sia ancora più indietro: forse un buon docente riesce a incuriosire gli studenti, forse gli fa capire a cosa serve quell'equazione, forse presenta esempi illuminanti e legati al rendimento dei BTP, forse qualcuno inizia a percorrere gli impervi sentieri della matematica computazionale e della programmazione proprio grazie alle lezioni. Forse. Ma temo serva umiltà anche qui e non è detto che fra un po' ChatGPT non riesca ad essere simpatico e travolgente più di me e dei miei colleghi!

ps. In realtà il post non è finito e domani aggiungerò "Io, ChatGPT e julia" perché questo esperimento mi ha dato una frustata e ho deciso che, in barba al fatto che sto invecchiando, insegnerò anche un altro di linguaggio di programmazione oltre a R. Non voglio inseguire ChatGPT, è lui che deve rincorrere me!

ps2. Vi voglio anche raccontare un paio di altre cose "sbagliate" e di come ChatGPT si vada usato con cautela, le cantonate sono sempre in vista!