top of page

Intelligenza artificiale applicata in pratica con Q.bo STEM

Tanti anni fa, nel 1977, quando iniziai ad occuparmi di cibernetica, lo feci perché leggendo un libro di Silvio Ceccato, mi sembra si intitolasse “L’ABC della cibernetica”, ci misi tre settimane per cercare di capire quello che c’era scritto nelle prime tre pagine.


Dice Wikipedia: Filosofo irregolare, dopo aver proposto una definizione del termine "filosofia" e un'analisi dello sviluppo storico di questa disciplina, a partire dalla fine degli anni '40 ha preferito prenderne le distanze e perseguire la costruzione di un'opzione alternativa, denominata inizialmente "metodologia operativa" e in seguito "cibernetica della mente". (e gia questo, per un potenziale ribelle come ero a quel tempo, mi affascinava moltissimo).


Continua Wikipedia: Silvio Ceccato fu Saggista prolifico, ha scritto numerosi libri, saggi, e articoli, rendendosi noto in particolare nel campo della cibernetica.

Pur ottenendo notevole successo di pubblico con i suoi libri, riscosse scarso successo negli ambienti scientifici e filosofici accademici. (non poteva essere diversamente).


Fu tra i primi in Italia ad interessarsi alla traduzione automatica di testi, settore in cui ha fornito importanti contributi scientifici.

Negli anni sessanta sperimentò anche la relazione tra cibernetica e arte in collaborazione con il Gruppo V di Rimini.


L’intelligenza artificiale applicata in pratica con Q.bo STEM
L’intelligenza artificiale applicata in pratica con Q.bo STEM

Studioso della mente, intesa come l'insieme delle attività che l'uomo svolge per costituire i significati, memorizzarli ed esprimerli, ne propose un modello in termini di organo - funzione, scomponendo quest'ultima in fasi provvisoriamente elementari di un ipotetico organo, e nelle loro combinazioni in sequenze operazionali, in parte poi designate dalle parole e dalle frasi, o da altri codici utilizzati nei rapporti sociali.


Su questi argomenti pubblicò 21 volumi e centinaia di saggi.

Anche io a quel tempo, sebbene giovane scapestrato, studiavo queste cose, ma all’università, avevo “preferito” la praticità della vita (che per praticità della vita, bisogna intendere che, essendo figlio di emigranti, sebbene i miei genitori mi spingessero a continuare gli studi, io, vivendo con i nonni che ormai stavano diventando vecchi e soli, optai per un percorso più avventuroso, ma questo non lo potevo immaginare, sicuramente quello che volevo, era di essere di supporto a questi poveri vecchietti, se avessi trovato un buon lavoro, forse avrei anche avuto il tempo ( non so la voglia), di rimettermi in gioco con gli esami).


Così a ventitre, ventiquattro anni, mi ritrovai con un paio di negozi di informatica da gestire e una collaborazione con un laboratorio di elettronica.


Non c’era ancora internet, ovviamente, per studiare, mi compravo i libri, ma anche se giunsi davanti al portone di ingresso dell’università, per prendere i moduli, ritornai a casa, senza compilarli, dicendomi che, con il carattere che mi ritrovavo, (avevo litigato con qualche professoressa il giorno della verifica d’esame di italiano per la maturità, che mi bruciò il ‘60…), il dovere sociale che mi aveva costretto alla leva militare, lo avevo assolto, e non me la sentivo di dire ancora “Signor ssssisssignore!”.


Evidentemente la lettura del libro “Un Uomo” di Oriana Fallaci, aveva lasciato il segno sin da quel 1978, percui, siccome anche io, nel mio piccolo, avevo scritto un libro, che in piccola parte è stato riportato in alcuni articoli su questo sito, andai a trovare di persona, a Milano, questo grande faro, che mi aveva aiutato ad illuminare le parti più buie della mia mente.


Mi ricordo ancora che, nel lungo colloquio, ad un certo momento, quando gli dissi che mi dispiaceva non aver approfondito gli studi universitari, anche perché non c’era un corso di studi sulla cibernetica o sulla psicocibernetica, Lui mi disse, ma uno con le tue capacità, ha bisogno di un pezzo di carta per vivere? ( si sentiva tutta la sua delusione per il mondo accademico), credimi, mi disse, ha più soddisfazione un idraulico a Venezia, che un professore a Milano.


Fatto sta, che consegnai una copia dei miei appunti, una buona bottiglia di prosecco ed un salame nostrano, perché mi sembrava una cosa buona riportare alla memoria i nostri prodotti tipici, ad uno che probabilmente aveva origini Venete, e ritornai a casa, con un senso di tristezza e di malinconia, ma anche con la voglia di impegnarmi, a modo mio, nel cercare di fare qualcosa di utile.


Non ho mai voluto cercare ipocriti risconti su quelli che erano gli studi che conducevo, la vita poi mi riservò tante avventure, molto spesso brutte avventure, per cui, cercare di portare a casa “la pagnotta”, in una giungla di animali feroci, era già un buon risultato.


Quindi, tra una esperienza e l’altra approdai ad operare nell’ambito della impiantistica elettrica, poi nell’automazione industriale, nella robotica industriale, per finire anche ad occuparmi di intelligenza artificiale e robotica sociale.


Mai avrei detto, in quel lontano 1977 che, iniziare a studiare cibernetica, più per sopravvivenza che per curiosità, mi avrebbe portato a programmare una macchina (Q.bo STEM), che in qualche modo, usufruendo di un sistema interlacciato di informazioni, riuscisse, non solo a tradurre autonomamente delle frasi, da molte lingue diverse, ma riuscisse anche a parlare, (anche se ancora grezzamente), con dei fonemi appropriati, e soprattutto, a capire i comandi.


Era difficile allora, immaginare, dal basso delle mie conoscenze, che sarebbe stato possibile implemetare degli algoritmi, dei motori inferenziali, tali da permettere un simile approccio ai processi di traduzione.


Mentre adesso, è sin troppo semplice, dall’alto della piramide software necessaria per poter espletare questo compito, scrivere alcune righe di programma, per raggiungere i risultati che potete riscontrare nel video allegato.


In pratica, con circa trecento linee di codice in Python, si può fare in modo che Q.bo risponda ai comandi, riconosca in che lingua si intende tradurre la frase, permetta la traduzione in lingue diverse e la ripetizione della frase.


Ovvio, qualche volta sbaglia a capire le parole, (dipende da internet)… ma risulta essere lo stesso simpatico! In sintesi, come nella modalità più classica, la strutturazione del programma prevede il caricamento di alcune librerie fondamentali (che costituiscono la piramide), in modo particolare, si considerano le seguenti:


#!/usr/bin/python3
# import the necessary packages
import speech_recognition as sr
from deep_translator import GoogleTranslator
import re
import os
import subprocess
import wave
#import yaml
import time

Poi si passa al settaggio delle variabili utilizzate in questo processo:


# setting
for i, mic_name in enumerate(sr.Microphone.list_microphone_names()):
    if mic_name == "dmicQBO_sv":
        m = sr.Microphone(i)
        
print ("microphone is", m)
Query = ""
P_language = ""
Api_Lang = ""
translated = ""
start = True
end = False
first_translate = False
command = ""
counter = 0
new_Lang = False
Lang_verified = False
repeat = False
Phrase = ""
#------------------
Txt_start = "sono pronto, al momento, posso fare traduzioni in inglese, francese o spagnolo"
Txt_end = "va bene ciao"
Txt_end1 = "fine delle traduzioni, spero di esserti stato utile"
Txt_end2 = "però, aspetto che tu mi insegni a parlare in molte altre lingue!"

dopodicchè viene istanziata una classe:


class listen():
    def __init__(self):
        #global start, enc, P_language, Api_Lang, Txt, Query, command
        #global first_translate
        

e vengono definite le varie funzioni, una per il controllo dei comandi:



 def control_commands(self):
        global command, end, first_translate, new_Lang
        print ("command in control command is = ", command)
        if command != "":
            if "spegni" in command:
                print ("comando spegni attivato")
                command = ""
                end = True
                #.....
            if re.search(r'\s*cambia lingua', command):
               print("cambio lingua richiesto")
               first_translate = False
               new_Lang = True
               Lang_verified = False
               command = ""
               P_language = ""
               Api_Lang = ""

            if re.search(r'\s*ripeti*', command):
                global repeat
                print ("ripetizione richiesta")
                command = ""
                repeat = True

                
            if re.search(r'\s*smetti di tradurre', command):
                print ("richiesta di fine lavoro")             
                end = True

Una per il riconoscimento vocale del parlato italiano:



    def take_commands(self):
        global m, Query
        # initializing speech_recognition
        r = sr.Recognizer()
        # opening physical microphone of computer
        with m as source:
            r.adjust_for_ambient_noise(source)
            print('Ascolto...')
            r.pause_threshold = 1
            # storing audio/sound to audio variable
            audio = r.listen(source)
            try:
                print("Riconoscimento")
                # Recognizing audio using google api
                Query = r.recognize_google(audio, language="it_IT")
                command= Query.lower()
                print("Questo è ciò che ho capito='", command, "'")
            except Exception as e:
                print(e)
                print("Prova a ripetere, credo di non aver capito")
                # returning none if there are errors
                return "None"
        # returning audio as text
        time.sleep(2)
        return command



Una per la vocalità italiana:



    def Speak(self):
        global Txt
        print ("frase parlata", Txt)
        spk_now = 'espeak -v mb-it4 -s 120 -p 35 -w /tmp/temp.wav' +' " '+ Txt + ' " '+ '&& aplay -r 8000 -D      convertQBO /tmp/temp.wav'
        subprocess.call(spk_now, shell=True)


Una per le vocalità nelle lingue oggetto della traduzione:



    def Speak_Translate(self):
        print ("testo tradotto", translated)
        if Api_Lang == "en":
            spk_now = 'espeak -v mb-en1 -s 120 -p 35 -w /tmp/temp.wav' +' " '+ translated + ' " '+ '&& aplay -r 8000 -D      convertQBO /tmp/temp.wav'
            subprocess.call(spk_now, shell=True)

        if Api_Lang == "es":
            spk_now = 'espeak -v mb-es2 -s 120 -p 35 -w /tmp/temp.wav' +' " '+ translated + ' " '+ '&& aplay -r 8000 -D      convertQBO /tmp/temp.wav'
            subprocess.call(spk_now, shell=True)
            
        if Api_Lang == "fr":
            spk_now = 'espeak -v mb-fr1 -s 120 -p 80 -w /tmp/temp.wav' +' " '+ translated + ' " '+ '&& aplay -r 8000 -D      convertQBO /tmp/temp.wav'
            subprocess.call(spk_now, shell=True)


Una per la verifica del riconoscimento della richiesta inerente la lingua “target”:



    def verify(self):
        global Lang_verified
        global Api_Lang 
        global P_language
        print ("contollo in verify", P_language)
        if re.search(r'\s*francese', P_language):
            print("lingua riconosciuta", P_language)
            Api_Lang = "fr"
        elif re.search(r'\s*inglese', P_language):
            print("lingua riconosciuta", P_language)
            Api_Lang = "en"
        elif re.search(r'\s*spagnolo', P_language):
            print ("lingua riconosciuta", P_language)
            Api_Lang = "es"
        elif re.search(r'\s*portoghese', P_language):
            print ("lingua riconosciuta", P_language)
            Api_Lang = "pt"
        if Api_Lang !="":
            Lang_verified = True
        else:
            P_language = ""
            Api_Lang = ""
            print ("verify non riconosce la lingua")
            command = ""
            Lang_verified = False


ed infine una per la richiesta di traduzione alla I.A. remota:



    def translator(self):
        global translated
        print ("Api_Lang = ", Api_Lang)
        translated = GoogleTranslator(source = 'it', target = Api_Lang).translate(Phrase)
        print("traduzione",translated)


Infine, le istruzioni di processo: prima di eseguire il codice, l’interprete Python legge il codice sorgente e definisce alcune variabili globali speciali, tra cui la variabile __name__ a cui viene assegnato il nome del modulo principale in esecuzione.

Un modulo è un file contenente definizioni e dichiarazioni in Python.



if __name__=='__main__':
    """ Main void.

    Is the main void executed when started. It does:
    - Start the node
    - Create an object of the class
    - Run the node

    """

     while True:
 
         print("devo tradurre in che lingua?", P_language)
         print("o capire un comando?", command)
         print ("start=", start)
         if start == True:
             start = False
             Txt = Txt_start
             listen.Speak(Txt)
         command = listen.take_commands(m)
         listen.control_commands(command)
         print ("command", command)
         print ("controllo comandi effettuato", "end=", end)
 
         if end == True:
             print ("game over")
             print ("comando spegni in esecuzione")
             Txt = Txt_end
             command = ""
             start = False
             listen.Speak(Txt)
             Txt = Txt_end1
             listen.Speak(Txt)
             Txt = Txt_end2
             listen.Speak(Txt)
             #os.system("shutdown -h now")
             break
         
         P_language = command
         if Lang_verified == False:
             listen.verify(P_language)
             print ("Lang_verified =", Lang_verified)
             print ("lingua target =", Api_Lang)
             
         print ("controllo cambio lingua", "new_Lang=", new_Lang)
         print ("Api_Lang verificato:", Api_Lang)
         
         if Api_Lang !="" and new_Lang == True:
             print ("richiesta cambio lingua in corso")
             new_Lang = False
             Lang_verified = False
             Query = ""
             Txt = "sono pronto, dimmi in che lingua devo fare la traduzione"
             listen.Speak(Txt)
             command = listen.take_commands(m)
             P_language = command
             listen.control_commands(command)
             listen.verify(P_language)
             print ("verifica cambio lingua effettuata")
 
         if Api_Lang == "":
             print ("lingua non riconosciuta")
             Txt = "mi dispiace, non ho riconosciuto il nome della lingua, puoi ripetere?"
             Query = ""
             listen.Speak(Txt)
             Query = ""
             Txt =""
             P_language = ""
             first_translate = False
             command =""
             Lang_verified = False
 
             
         if Lang_verified == True and first_translate == False:
             print ("Lingua riconosciuta, prima traduzione")
             Query = ""
             if Api_Lang == "es":
                 Query = "spagnolo"
             if Api_Lang == "en":
                 Query = "inglese"
             if Api_Lang == "fr":
                 Query = "francese"
             Txt= "la lingua che mi hai indicato dovrebbe essere " + Query
             listen.Speak(Txt)
             Query = ""
             Txt = "Dimmi la frase che vorresti tradurre"
             listen.Speak(Txt)
             Txt=""
             command = listen.take_commands(m)
             Phrase = command
             Txt = "la frase dovrebbe essere," + Phrase  
             listen.Speak(Txt)
             Query =""
             Txt = "che nella lingua da te richiesta, si traduce in questo modo: "
             listen.Speak(Txt)
             Txt = ""
             listen.translator(Phrase)
             listen.Speak_Translate(translated)
             first_translate = True
             print ("in attesa di comando")
             
         elif Api_Lang != "" and repeat == True:
             repeat = False
             listen.Speak_Translate(translated)
             
             
         elif Api_Lang != "" and re.search(r'\s*altra frase*', command):
             print ("chiede altra frase")
             Query = ""
             Txt = "Dimmi la frase che vorresti tradurre"
             listen.Speak(Txt)
             Txt=""
             command = listen.take_commands(m)
             Phrase = command
             Txt = "questa frase dovrebbe essere," + Phrase  
             listen.Speak(Txt)
             Query =""
             Txt = "che, se non sbaglio,si traduce così: "
             listen.Speak(Txt)
             Txt = ""
             listen.translator(Phrase)
             listen.Speak_Translate(translated)
             print ("frase tradotta")
   
 
         elif Query != "":     
             Txt = "mi sembra di aver capito," + Query  
             listen.Speak(Txt)
             Query = ""
             Txt = "ma non saprei come posso fare per esaudire il tuo desiderio!"
             listen.Speak(Txt)
             Query = ""
             Txt = "vuoi farmi un'altra domanda o spengo?"
             #------------------------
             print ("P_language attuale ", P_language)
             listen.Speak(Txt)
             Txt = ""
             command =""
             print ("controllo finale")
 
         else:
             print ("aspetta comandi")
             command = listen.take_commands(m)
             listen.control_commands(command)
             Query = ""
             Txt = ""
             command = ""
             counter += 1
             print (" in tutti gli altri casi incrementa counter", counter)


Detto questo, il gioco è fatto, si fa per dire!


Ecco un video dell'output :



( Acquistabile con il Bonus Cultura e Carta docente )


Un ringraziamento particolare per tutti coloro che hanno dedicato il loro tempo prezioso a questa lettura, che spero possa essere di stimolo per le nuove generazioni, a cercare di “imparare ad imparare”, come dice Q.bo STEM, in alcuni video, senza mai farsi condizionare da false aspettative, consci del fatto che l’unica ricchezza che abbiamo è la nostra conoscenza, che va coltivata, come si coltivano le cose buone che ci dona la natura, scartando le erbacce che infestano il campo (appunto il campo di conoscenza che non è solo un big-data). Se siete interessasti ad aggiornamenti e video su Q.bo STEM potete seguirmi quì : https://patreon.com/Qbo_STEM



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