(prima di tutto connetti il cervello, poi la memoria ed infine usa gli strumenti giusti)
Git è lo strumento software essenziale per incominciare a lavorare con l’intelligenza artificiale, lo si può utilizzare sin dai primi passi, magari assieme alla tua IDE (Integrated Development Environment, ovvero ambiente di sviluppo integrato) o editor di programmazione preferito.
Git è un progetto open source, forse quello più utilizzato in assoluto, in quanto estremamente utile, ideato e sviluppato nel 2005 da Linus Torvalds (vi dice nulla?), il creatore del kernel del sistema operativo Linux!
Git fondalmentalmente è un software per il controllo delle “versioni”, più precisamente, un DVCS (Distributed Version Control System, sistema di controllo delle versioni distribuito), ma, oltre ad essere distribuito, Git è stato progettato per fornire prestazioni, sicurezza e flessibilità.
Le funzionalità principali che consentono di sottoporre a “commit” le nuove modifiche, di creare “branch”, di eseguire il “merge” e di fare un confronto con le versioni precedenti sono tutte ottimizzate per fornire ottime prestazioni.
Gli algoritmi implementati all'interno di Git sfruttano tutti i dati inerenti gli attributi comuni degli alberi dei file di codice sorgente reali, di come vengono solitamente modificati nel tempo e dei modelli di accesso.
In particolare, l’oggetto dei file del repository Git utilizza una combinazione di codifica delta (archiviazione delle differenze di contenuto, tramite le sequenze dei commit) e compressione (come il formato zip, inoltre, archivia esplicitamente i contenuti delle directory e gli oggetti dei metadati della versione.
Ad esempio, supponiamo che uno sviluppatore apporti modifiche al codice sorgente, aggiungendo del codice e quindi esegua il commit di tali modifiche con messaggi descrittivi. In seguito poi apporti ulteriori modifiche ed esegua un nuovo commit. Git, archivierà questa sequenza di operazioni, identificandone ogni dettaglio. Se lo sviluppatore passa le modifiche su uno dei rami dell’archivio, (effettua un branch), ad esempio quello inerente all’ambiente di test o di sviluppo, potrà condividere il suo lavoro con altri, Se effettua un “push” in cloud, dove viene condiviso il progetto, senza dover intaccare il ramo principale del progetto (main).
Git - Il tool essenziale per l’intelligenza artificiale
Riassumendo, i repository online e locali possono essere divisi in ramificazioni (Branch). I branch (ramificazioni) permettono di creare delle versioni assestanti del codice master. Queste versioni "assestanti" permettono la creazione di features o aggiornamenti in fase alpha che non vanno ad intaccare minimamente il codice del progetto. Finito la scrittura della ramificazione il branch verrà unito con il master (main). Git permette di gestire i tag. I tag sono le versioni del software in uso. I tag registrano tutti i commit fino al rilascio nel server.
Git è stato concepito, considerando come priorità imperativa, la tutela dell'integrità del codice sorgente gestito. Il contenuto dei file e le reali relazioni tra file e directory, le versioni, i tag e i commit, tutti oggetti nel repository Git, sono protetti da un algoritmo di “hashing”, sicuro a livello di crittografia, chiamato SHA1.
Questo algoritmo protegge il codice e la cronologia delle modifiche da variazioni accidentali e dannose, garantendo la completa tracciabilità della cronologia. Uno dei principali obiettivi di progettazione di Git è la flessibilità. Git è flessibile sotto diversi aspetti: è in grado di supportare vari tipi di flussi di lavoro e di sviluppo non lineare, offre efficienza in progetti di piccole e grandi dimensioni ed è compatibile con molti sistemi e protocolli esistenti.
Git, dovrebbe essere la priorità nella scelta di apprendimento per un sviluppatore inesperto che desidera acquisire competenze preziose negli strumenti di sviluppo software, in particolare se si vuole intraprendere un percorso di apprendimento nell’ambito del software utilizzato in ambito dello sviluppo di applicazioni di intelligenza artificiale.
Ovviamente, la documentazione è eccellente e vasta, con libri, tutorial e siti Web dedicati, podcast e i video tutorial.
La caratteristica open source riduce i costi per gli sviluppatori amatoriali consentendo loro di utilizzare Git senza pagare una commissione.
Come installare di GIT
Per gli utenti windows: https://gitforwindows.org/
Per utenti Linux (dovrebbe essere installato di default ovviamente). In qualsiasi caso: $ sudo apt-get update $ sudo apt-get install git
Per gli utenti OS (se non installato): https://sourceforge.net/projects/git-osx-installer/files/
I principali comandi GIT
Per lavorare con GIT ci vuole un po’ di impegno che lo sviluppatore alle prime armi, dovrebbe impiegare per famigliarizzare con i comandi che questo tool richiede per effettuare le varie procedure di utilizzo.
Uno dei comandi principali è sicuramente quello che permette di “clonare” un progetto esistente, presente in rete, ad esempio nella piattaforma GitHub.
Per inciso, GitHub è un servizio di hosting per progetti software, di proprietà della società GitHub Inc. git clone è un comando per scaricare il codice sorgente esistente da un repository remoto (come elemento di Github, per esempio).
In altre parole, git clone praticamente fa una copia identica dell'ultima versione di un progetto in un repository e la salva sul tuo computer locale.
Esempio:
git clone https://github.com/cheshire-cat-ai/core.git cheshire-cat scarica il progetto di Piero Savastano cheshire-cat-ai : un framework per creare servizi di intelligenza artificiale personalizzati utilizzando qualsiasi LLM. Cheshire-Cat (Stregatto) Questo comando genera in locale una directory corrispondente al progetto esistente:
git branch è il comando con il quale si può generare il “ramo” sul quale operare in locale. I branch sono molto importanti nel mondo Git. Usando i branch, parecchi sviluppatori sono in grado di lavorare in parallelo sullo stesso progetto simultaneamente.
Se si apre una CLI (terminale) nella directory generata dal clone (ci si può accedere anche con cd cheshire-cat). Se invece si volesse fare una prova preliminare, con un proprio progetto o “repository”, si potrebbe creare una cartella apposita ed accedervi anche imparando ad usare la <CLI> terminale con le istruzioni:
magoo@magoo:~/U_2023_D$ mkdir prova
magoo@magoo:~/U_2023_D$ cd prova
magoo@magoo:~/U_2023_D/prova$ git init è il comando da usare per il setup iniziale di un repository.
magoo@magoo:~/U_2023_D/prova$ git init 
suggerimento: Utilizzo di 'master' come nome per il ramo iniziale. Questo nome ramo predefinito suggerimento: è soggetto a modifiche.
L’esecuzione di questo comando crea la sottodirectory .git nella directory in cui viene eseguito (la directory del progetto); nessun file viene aggiunto o modificato oltre alla sottodirectory .git
All’interno della directory (nascosta) .git vengono creati tutti i metadati necessari a Git (branch di default, oggetti, reference, file template, …). La maggior parte dei comandi Git sono disponibili solo se eseguiti all’interno di un repository inizializzato.
È, ovviamente, possibile inizializzare una directory diversa da quella corrente indicando il percorso:
git init /path/to/project/directory A questo punto, all’intrno della directory “prova”, si può editare un file, come questo, che servirà per fare una prova di utilizzo del linguaggio Python, per passare da testo scritto a sintesi vocale:
#test_to_speak
# apt-get install espeak -y
import subprocess
import time
lang = "en+f5"
speaker = True
message = "Hi I'm cheshire cat"
print (message)
#---------------
def Speak():
global message, lang
print (message)
spk_now = 'espeak -v'+lang +' " '+ message + ' " '
#print(spk_now)
subprocess.call(spk_now, shell=True)
#time.sleep (1)
#----------
if speaker:
Speak()
#-------------------
nota: per il funzionamento di questo file è necessario installare eSpeak che è un sintetizzatore
vocale software open source compatto per l'inglese e altre lingue, per Linux e Windows.
Possiamo controllare lo stato del nostro repositori con il comando git status:
magoo@magoo:~/U_2023_D/prova$ git status Sul branch master Non ci sono ancora commit :
File non tracciati:
(usa "git add <file>..." per includere l'elemento fra quelli di
cui verrà eseguito il commit)
test_to_speak.py non è stato aggiunto nulla al commit ma sono presenti file non tracciati (usa "git add" per tracciarli) con questo comando si possono visualizzare diverse informazioni, tra le quali:
controllare se il branch corrente è aggiornato
controllare se c'è qualcosa da passare a commit, da inviare al repository oppure da ottenere dal repository
controllare se ci sono file nell'area di stage, non passati all'area di stage oppure non tracciati
controllare se ci sono file creati, modificati o cancellati
Il “tracciamento” dei file avviene mediante commit, ma per poterlo effettuare è necessario aggiungere il file al controller Git, il comando, in questo caso dovrà essere:
git add test_to_speak.py il risultato viene riportato di seguito:
magoo@magoo:~/U_2023_D/prova$ git add test_to_speak.py
magoo@magoo-Strix-GL504GM:~/U_2023_D/prova$ git status Sul branch master Non ci sono ancora commit
Modifiche di cui verrà eseguito il commit:
(usa "git rm --cached <file>..." per rimuovere gli elementi
dall'area di staging)
nuovo file: test_to_speak.py Il file appena aggiunto viene portato in uno stato di “staging”, ovverosia è pronto per essere “committato”, o per meglio dire, in termini meno tecnici “tracciato”. Se si volessero aggiungere tutti i file di un repository, il comando sarebbe git add -A. Se adesso si volesse effettuare il commit però, Git risponderebbe con un errore, come riportato dalle seguenti linee di comando:
magoo@magoo:~/U_2023_D/prova$ git commit -m "aggiunto file test per python"
Identità autore sconosciuta
Dimmi chi sei.
Esegui
git config --global user.email "tu@esempio.com"
git config --global user.name "Il tuo nome"
per impostare l'identità predefinita del tuo account.
Ometti --global per impostare l'identità solo in questo repository.
fatal: impossibile rilevare automaticamente l'indirizzo e-mail (ho ricavato
'magoo@magoo-Strix-GL504GM.(none)')
Come è giusto che sia, daltronde, Git è stato concepito appositamente per una funzionalità “collaborativa”, dove ogni autore deve essere riconosciuto. Quindi, seguendo le istruzioni suggerite, si portà effettuare il commit in modo corretto, sul branch nel quale si sta operando:
magoo@magoo-Strix-GL504GM:~/U_2023_D/prova$ git config user.email
romeo.ceccato@gmail.com
magoo@magoo-Strix-GL504GM:~/U_2023_D/prova$ git config user.name magoo
magoo@magoo-Strix-GL504GM:~/U_2023_D/prova$ git commit -m "aggiunto file test in python" [master (commit radice) f4e4e27] aggiunto file test in python
1 file changed, 21 insertions(+)
create mode 100644 test_to_speak.py Per vedere il risultato di questa operazione, si utilizza il comando git log, più in generale, questa funzionalità è specialmente utile per ottenere un riepilogo dello “storico” delle operazioni effettuate e tracciate.
Vale sempre la pena di perfezionare i criteri di ricerca per ottenere risultati migliori, specialmente quando si tratta di progetti di grandi dimensioni.
A questo scopo Git offre numerose possibilità, come riportato da questa tabella: In questo caso il comando git log produrrà il seguente risultato:
magoo@magoo:~/U_2023_D/prova$ git log
commit f4e4e274766a502d77c1f89c17a26143494c8632 (HEAD -> master)
Author: magoo <romeo.ceccato@gmail.com>
Date: Thu Jun 8 15:36:55 2023 +0200
aggiunto file test in python
Se, lo stesso comando lo avessimo fatto, all’interno della directory di Cheshire_cat, otterremmo qualcosa di diverso, come nell’esempio di seguito riportato:
commit f6d4ec26157afebf1200c0b6bf3e5092b1312639 (HEAD -> main, origin/main,
origin/HEAD, test_beta)
Author: pieroit <piero.savastano@gmail.com>
Date: Fri Jun 2 21:21:13 2023 +0200
.env is optional
commit b5058cebd21589e4939dd644d6c900b79c906025
Author: Piero Savastano <piero.savastano@gmail.com>
Date: Thu Jun 1 22:52:17 2023 +0200
Update how-to-write-a-plugin.md
commit 13c69932d30d0be62701807054a8f09565d3b2ef
Author: Piero Savastano <piero.savastano@gmail.com>
Date: Thu Jun 1 22:32:21 2023 +0200
Update README.md
commit 4993de08257f74ed0d39125f6118522fe097b264
Author: Piero Savastano <piero.savastano@gmail.com>
Date: Thu Jun 1 19:48:55 2023 +0200 Possiamo usare il comando git branch per creare, elencare ed eliminare branch. Esempio:
git branch test_beta
genera un ramo di lavoro denominato test_beta, se eseguiamo questo comando all’interno della directory “prova”, otterremmo il seguente risultato:
magoo@magoo:~/U_2023_D/prova$ git branch test_beta
magoo@magoo:~/U_2023_D/prova$ git log
commit f4e4e274766a502d77c1f89c17a26143494c8632 (HEAD -> master, test_beta)
Author: magoo <romeo.ceccato@gmail.com>
Date: Thu Jun 8 15:36:55 2023 +0200
aggiunto file test in pythonA questo punto, si potrebbe desiderare di lavorare su questo ramo, per evitare eventuali modifiche indesiderate al ramo principale master (main).
Per questo, si può utilizzare il comando git checkout.
git checkout <nome branch> è il comando che permette di “spostare”, l’ambiente di lavoro, al ramo desiderato.
Esempio:
git checkout test_beta
magoo@magoo:~/U_2023_D/prova$ git checkout test_beta
Si è passati al branch 'test_beta' Se adesso andassimo a fare delle modifiche al file in python, come ad esempio queste:
#test_to_speak
# apt-get install espeak -y
import subprocess
import time
lang = "en+f5"
#lang = "it+f5"
speaker = True
message = "Hi I'm cheshire cat"
#message = "ciao io sono lo Stregatto"
print (message)
#---------------
def Speak():
global message, lang
print (message)
spk_now = 'espeak -v'+lang +' " '+ message + ' " '
#print(spk_now)
subprocess.call(spk_now, shell=True)
#time.sleep (1)
#----------
if speaker:
Speak()
ed andassimo a controllare lo stato del repository, otterremmo qualcosa di analogo a questo:
magoo@magoo:~/U_2023_D/prova$ git status
Sul branch test_beta
Modifiche non nell'area di staging per il commit:
(usa "git add <file>..." per aggiornare gli elementi di cui sarà eseguito il
commit)
(usa "git restore <file>..." per scartare le modifiche nella directory di
lavoro)
modificato: test_to_speak.py
nessuna modifica aggiunta al commit (usa "git add" e/o "git commit -a") Quindi si potrebbe a questo punto effettuare un ulteriore commit seguendo le istruzioni di cui sopra:
magoo@magoo:~/U_2023_D/prova$ git add .
magoo@magoo:~/U_2023_D/prova$ git commit -m "modifiche al file di test" [test_beta 9f7dc90] modifiche al file di test
1 file changed, 2 insertions(+), 1 deletion(-) permette di operare le modifiche al codice, senza apportare modifiche indesiderate al 'origin/main' o al branch <master>.
Se volessimo verificare lo stato storico del repository, vedremmo quanto segue:
magoo@magoo:~/U_2023_D/prova$ git log
commit 9f7dc9036bf7a978953b4e004e7388b00ad6fa78 (HEAD -> test_beta) Author: magoo <romeo.ceccato@gmail.com>
Date: Thu Jun 8 16:29:53 2023 +0200
modifiche al file di test
commit f4e4e274766a502d77c1f89c17a26143494c8632 (master)
Author: magoo <romeo.ceccato@gmail.com>
Date: Thu Jun 8 15:36:55 2023 +0200
aggiunto file test in python Se, a questo punto, si volesse controllare le modifiche tra i due file presenti nei brach master e in test-beta, lo si potrebbe fare mediante il comendo git diff, come riportato dalle seguenti linee di comando della CLI:
magoo@magoo:~/U_2023_D/prova$ git diff test_beta master diff --git a/test_to_speak.py b/test_to_speak.py
index f64f430..a04a09c 100644
--- a/test_to_speak.py
+++ b/test_to_speak.py
@@ -3,10 +3,9 @@
import subprocess
import time
lang = "en+f5"
-#lang = "it+f5"
+
speaker = True
message = "Hi I'm cheshire cat"
-#message = "ciao io sono lo Stregatto"
print (message)
#--------------- Per concludere questa piccola introduzione all’impiego di Git, potrei invitarvi a far eseguire il codice in python, ricordando che vi sono molti altri comandi essenziali per poter lavorare con Git, come ad esempio quello che permette di fondere i file nel ramo di test con quelli del ramo principale di lavoro (master) per il repository di prova.
Se si osserva, con il comado git log, quando si è su un barach, viene indicata la posizione:
magoo@magoo:~/U_2023_D/prova$ git log commit a2ee0cdc4b49414987bed98d0386fae77411b816 (HEAD -> master) Nel nostro caso, se non si è nel ramo master, eseguiremo git checkout main. Se si lavora con repository remoti sarà bene assicurarsi che il branch di destinazione e quello che verrà sottoposto a merge siano aggiornati con le ultime modifiche remote, Eseguendo il comando git fetch per eseguire in seguito un pull dei commit remoti più recenti.
In questo caso, per semplicità illusrto solo il l’effetto del comando git merge:
magoo@magoo:~/U_2023_D/prova$ git merge test_beta
Merge automatico di test_to_speak.py in corso
Merge made by the 'ort' strategy.
test_to_speak.py | 1 +
1 file changed, 1 insertion(+)
considerazioni finali Ovviamente, questo è solo un piccolo assaggio di ciò che comporta lavorare con Git e con la comuniti di github che ad un alto livello, corrisponde ad un servizio web e cloud-based che aiuta gli sviluppatori ad archiviare e gestire il loro codice e a tracciare e controllare le modifiche.
La conoscenza dei comandi Git, quindi, può essere considerata come prerogativa base per accedere ad un qualsiasi colloquio di lavoro da parte di chi aspira a divenire uno sviluppatore di software per l’intelligenza artificiale.
Git, in particolare, dovrebbe essere preso in considerazione perché può essere impiegato in molte applicazioni dove si vuole facilitare la collaborazione di intenti, anche al di fuori dello sviluppo di software.
In tutto questo, vi chiederete, cosa centra lo Stregatto? Cheshire cat A.I. è un progetto ideato da Piero Savastano, che con molta lungimiranza ha intravisto la possibilità di attuare quello che si può considerare una piattaforma di sviluppo simile a Wordpress, ma orientata all’intelligenza artificiale, a mio avviso e spero che sia anche l’opinioni di altri esperti del settore, questo sarà sicuramente uno dei progetti più interessanti a livello mondiale in questo settore.
A proposito, Chesire cat gioca nei contenitori di Docker, di cui ne ho parlato in questo articolo:
https://www.intelligenzaartificialeitalia.net/post/i-contenitori-di-intelligenza-artificiale Il mio invito, pertanto è quello di collaborare a questa iniziativa che, affiliandosi alle direttive e allo spirito del freeware, ma soprattutto del open source, mantiene uno spirito morale libero, che promuove la sinergia, la collaborazione e la sussidiarietà, nello sviluppo di applicazioni etiche a livello mondiale, ma che, in questo ultimo periodo, sembrano minacciate da un accentramento tecnocratico che in nome del profitto e del controllo, ne minaccia il futuro.
Grazie per la lettura Romeo Ceccato
.png)
