top of page

Git - Il tool essenziale per l’intelligenza artificiale

(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 - Il tool essenziale per l’intelligenza artificiale
Git - Il tool essenziale per l’intelligenza artificiale

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.


Git - Il tool essenziale per l’intelligenza artificiale
Git - Il tool essenziale per l’intelligenza artificiale

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 - Il tool essenziale per l’intelligenza artificiale
Git - Il tool essenziale per l’intelligenza artificiale

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 

Git - Il tool essenziale per l’intelligenza artificiale
Git - Il tool essenziale per l’intelligenza artificiale

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 python


A 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

Comments

Rated 0 out of 5 stars.
No ratings yet

Add a rating
PCR (5).gif
PCR (4).gif
PCR.gif
PCR.gif
PCR.gif
PCR.gif
PCR (5).gif
3.gif
Vediamo se riesci a cliccarmi ! Nascondo una Sorpresa... (2).png

Ciao 

🤗 Articoli consigliati dalla nostra
Intelligenza Artificiale in base ai tuoi interessi

Correlazione Alta

Correlazione Media

Correlazione Bassa

Iscriviti

VUOI DIVENTARE UN MEMBRO DI INTELLIGENZA ARTIFICIALE ITALIA GRATUITAMENTE E TRARNE I SEGUENTI BENEFICI?

Corsi Gratis

più di 150 lezioni online

Dataset Gratis

più di 150o dataset

Ebook Gratis

più di 10 libri da leggere

Editor Gratis

un editor python online

Progetti Gratis

più di 25 progetti python

App Gratis

4 servizi web con I.A.

Unisciti Ora a oltre
1.000.000
di lettori e appassionanti d'I.A.

Tutto ciò che riguarda l'intelligenza Artificiale, in unico posto, in italiano e gratis.

MEGLIO DI COSI' NON SI PUO' FARE

Dopo l'iscrizione riceverai diversi Regali

VUOI SCRIVERE ARTICOLI INSIEME A NOI.

Grazie

bottom of page