Il programma te lo scrive la A.I.

Zzed 21 Gennaio 2023 Corso Python, Curiosità, News Lascia un commento 1,522 Visualizzazioni

Introduzione

Sicuramente ne avete sentito parlare, perché è sulla bocca di tutti, anche di chi non si è mai interessato a questo mondo: ChatGPT . Cosa tratteremo in questa guida? Introdurrò il fenomeno ChatGPT, presentandovelo, lo useremo per farci scrivere il codice che desideriamo, creeremo un assistente virtuale vocale intelligente e acquisiremo la consapevolezza di avere un nuovo potere..

Cosa è

ChatGPT è una IA, Intelligenza Artificiale, o meglio, è un chatbot sviluppato per conversare via chat con gli umani, dando risposte coerenti e contestualizzate come farebbe un umano. È sviluppato da OpenAI, organizzazione non-profit di ricerca sull’intelligenza artificiale che promuove lo sviluppo delle cosiddette Ai amichevoli – intelligenze capaci di contribuire al bene dell’umanità, soggette a precisi controlli e equilibri del loro processo evolutivo. Quindi, sebbene il suo uso sia stupefacente per la maggior parte delle persone, tranquilli, ChatGPt non conquisterà il mondo per eliminare gli umani, come nei film distopici poco originali.

La versione attuale di ChatGPT si basa su GPT-3, una IA in grado di riconoscere il linguaggio naturale, e di pescare da un database enorme (anche quanto presente online fino a fine 2021) per comporre delle risposte in un linguaggio altrettanto naturale, molto simile a quello che userebbe una persona. Anche in italiano. Qui scriverò cosa le ho chiesto, e riporterò in blu e corsivo le risposte ottenute.

(dopo il gran clamore ottenuto, il sito web su cui si può interagire con ChatGPT è spesso sovraccarico in questi primi giorni dopo il suo lancio, e non è possibile usare lo strumento nelle ore “di punta”. Il sito è questo , lo stesso che ospita il generatore di immagini, partendo dalla loro descrizione testuale, DALL-E.

Una volta registrati, si potrà accedere alla chat con ChatCPT, se il traffico lo consente.

Comunque, per ora, leggete questa guida per farvi una idea di come funziona. Qui scriverò cosa le ho chiesto, e riporterò in blu e corsivo le risposte ottenute.

Presentazioni

Ciao ChatGPT. Sto scrivendo un articolo su di te per il portale www.raspberryitaly.com. Presentati, spiega ai lettori cosa sei

…

Ciao! Sono ChatGPT, un modello di linguaggio di grandi dimensioni sviluppato da OpenAI. Mi è stato addestrato su una grande quantità di testo proveniente da Internet per generare risposte plausibili e pertinenti a una vasta gamma di domande. Sono in grado di comprendere il linguaggio naturale e di generare testo in modo autonomo, il che mi rende utile per una serie di applicazioni, come la creazione di contenuti, la traduzione automatica e la risposta alle domande degli utenti. Spero di esserti stato d’aiuto!

Al di là dell’errore ortografico (lo ho ripreso correggendolo e mi ha risposto “Scusa hai ragione, avrei dovuto scrivere ‘sono stato addestrato…’ Grazie per avermelo fatto notare”), si è scordato di dirci una delle sue skill “collaterali”: è in grado di scrivere codice in molti linguaggi e Python è tra i suoi preferiti.

ChtaGPT è in grado di scrivere post, articoli, testi per video, nello stile che preferiamo (istituzionale, epico, ironico, ecc.). Ma se la cava abbastanza bene anche con un altro tipo di linguaggio: quello della programmazione. Può infatti scrivere codice nei più diffusi linguaggi di programmazione, tra cui Python, JavaScript, C++, Java, C#, e altri ancora pescando le conoscenze dai tanti esempi di siti come Stack Overflow, o i vari corsi online, o anche creare semplici pagine web, con tanto di foglio di stile CSS.

Il super potere del codice

Avete già capito la portata di potenzialità del genere? Questo mette nelle nostre mani, dopo il Raspberry Pi, un altro strumento enormemente potente: Un super potere con cui fare qualsiasi cosa, o quasi. Certo, non sarà magari perfetto, ma ci fornisce una gran bel canovaccio già pronto, su cui lavorare.

Esempi in Python

Proviamo, ad esempio, a chiedergli qualche riga di codice per un compito prettamente informatico

crei uno script python che controlli una determinata cartella e mandi un avviso via mail quando viene aggiunto un file in quella cartella? Il messaggio di avviso dovrà contenere il nome del file che è stato aggiunto.

import os
import smtplib
import time
from email.mime.text import MIMEText

# percorso della cartella da controllare
folder_path = "path/to/folder"

# numero di file nella cartella all'avvio dello script
initial_file_count = len(os.listdir(folder_path))

while True:
    # controlla se ci sono nuovi file nella cartella
    current_file_count = len(os.listdir(folder_path))
    if current_file_count > initial_file_count:

        # nuovo file aggiunto
        new_file = os.listdir(folder_path)[-1]
        print("Nuovo file aggiunto: " + new_file)

        # configura la connessione SMTP
        server = smtplib.SMTP('smtp.gmail.com', 587)
        server.starttls()
        server.login("your_email@example.com", "your_password")

        # crea il messaggio email
        msg = MIMEText("Nuovo file aggiunto: " + new_file)
        msg['Subject'] = "Avviso di nuovo file aggiunto"
        msg['From'] = "your_email@example.com"
        msg['To'] = "destination_email@example.com"

        # invia l'email
        server.sendmail("your_email@example.com", "destination_email@example.com", msg.as_string())
        server.quit()

        # aggiorna il numero di file nella cartella
        initial_file_count = current_file_count
        time.sleep(10)

import os

import smtplib

import time

from email.mime.text import MIMEText

# percorso della cartella da controllare

folder_path = "path/to/folder"

# numero di file nella cartella all'avvio dello script

initial_file_count = len(os.listdir(folder_path))

while True:

# controlla se ci sono nuovi file nella cartella

current_file_count = len(os.listdir(folder_path))

if current_file_count > initial_file_count:

# nuovo file aggiunto

new_file = os.listdir(folder_path)[-1]

print("Nuovo file aggiunto: " + new_file)

# configura la connessione SMTP

server = smtplib.SMTP('smtp.gmail.com', 587)

server.starttls()

server.login("your_email@example.com", "your_password")

# crea il messaggio email

msg = MIMEText("Nuovo file aggiunto: " + new_file)

msg['Subject'] = "Avviso di nuovo file aggiunto"

msg['From'] = "your_email@example.com"

msg['To'] = "destination_email@example.com"

# invia l'email

server.sendmail("your_email@example.com", "destination_email@example.com", msg.as_string())

server.quit()

# aggiorna il numero di file nella cartella

initial_file_count = current_file_count

time.sleep(10)

In questo script, utilizziamo un ciclo while True per continuare a controllare la cartella specificata. All’interno del ciclo, utilizziamo os.listdir(folder_path) per ottenere l’elenco dei file nella cartella e confrontiamo il numero di file con il numero di file all’avvio dello script. Se ci sono più file adesso, significa che un nuovo file è stato aggiunto. Utilizziamo la libreria smtplib per connettersi al server di posta elettronica (in questo caso google) e la libreria email.mime.text per creare la struttura del messaggio e inviarlo. Nella funzione server.login() devi inserire la tua mail e password. e nella funzione server.sendmail() devi inserire l’email del mittente e l’email del destinatario.

Nota: questo script utilizza un server SMTP di Google per inviare la mail, quindi è necessario avere un account Gmail e permettere l’accesso

Come vedete, non solo scrive il codice, ma poi lo spiega anche!

Passiamo al physical computing!

Ora, proviamo qualcosa di inerente anche l’hardware di Raspberry Pi: non solo software ma anche elementi fisici collegati al GPIO e parametri del mondo reale: ad esempio una stazione meteo con sensore di temperatura e umidità DHT22 e visualizzazione su un display LCD:

ecco come avviene la sessione di chat su ChatGPT. Ingrandisci a schermo intero.

scrivi uno script python per Raspberry Pi per una stazione meteo, che utilizzi un sensore DHT22 collegato al GPIO per leggere temperatura e umidità ambientali e le scriva su un display LCD collegato al GPIO

…

Ecco un esempio di script Python per una stazione meteo su Raspberry Pi che utilizza un sensore DHT22 e un display LCD:

…

import Adafruit_DHT
import RPi.GPIO as GPIO
import time

# Inizializzazione del sensore DHT22
DHT_SENSOR = Adafruit_DHT.DHT22
DHT_PIN = 4

# Inizializzazione del display LCD
LCD_RS = 25
LCD_E = 24
LCD_D4 = 23
LCD_D5 = 17
LCD_D6 = 18
LCD_D7 = 22
LCD_COLS = 16
LCD_ROWS = 2

GPIO.setmode(GPIO.BCM)
GPIO.setup(LCD_E, GPIO.OUT)
GPIO.setup(LCD_RS, GPIO.OUT)
GPIO.setup(LCD_D4, GPIO.OUT)
GPIO.setup(LCD_D5, GPIO.OUT)
GPIO.setup(LCD_D6, GPIO.OUT)
GPIO.setup(LCD_D7, GPIO.OUT)

lcd = Adafruit_CharLCD(LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7, LCD_COLS, LCD_ROWS)

while True:
    humidity, temperature = Adafruit_DHT.read(DHT_SENSOR, DHT_PIN)
    lcd.clear()
    lcd.message("Temp: {:.1f} C\nHumidity: {:.1f}%".format(temperature, humidity))
    time.sleep(1)

import Adafruit_DHT

import RPi.GPIO as GPIO

import time

# Inizializzazione del sensore DHT22

DHT_SENSOR = Adafruit_DHT.DHT22

DHT_PIN = 4

# Inizializzazione del display LCD

LCD_RS = 25

LCD_E = 24

LCD_D4 = 23

LCD_D5 = 17

LCD_D6 = 18

LCD_D7 = 22

LCD_COLS = 16

LCD_ROWS = 2

GPIO.setmode(GPIO.BCM)

GPIO.setup(LCD_E, GPIO.OUT)

GPIO.setup(LCD_RS, GPIO.OUT)

GPIO.setup(LCD_D4, GPIO.OUT)

GPIO.setup(LCD_D5, GPIO.OUT)

GPIO.setup(LCD_D6, GPIO.OUT)

GPIO.setup(LCD_D7, GPIO.OUT)

lcd = Adafruit_CharLCD(LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7, LCD_COLS, LCD_ROWS)

while True:

humidity, temperature = Adafruit_DHT.read(DHT_SENSOR, DHT_PIN)

lcd.clear()

lcd.message("Temp: {:.1f} C\nHumidity: {:.1f}%".format(temperature, humidity))

time.sleep(1)

Nota: questo script fa uso delle librerie Adafruit_DHT e Adafruit_CharLCD per la gestione del sensore DHT22 e del display LCD, rispettivamente. Assicurati di averle installate prima di provare questo script.

…

Mi metti lo schema di collegamento?

…

Ecco un esempio di schema di collegamento per utilizzare un sensore DHT22 e un display LCD con un Raspberry Pi:

Il sensore DHT22 è collegato al pin 4 del GPIO del Raspberry Pi (può essere modificato nel codice sopra)

Il pin 1 del sensore DHT22 è collegato al 3.3V del Raspberry Pi

Il pin 2 del sensore DHT22 è collegato al pin 4 del GPIO del Raspberry Pi

Il pin 3 del sensore DHT22 non è utilizzato

Il pin 4 del sensore DHT22 è collegato a terra del Raspberry Pi

Il pin RS del display LCD è collegato al pin 25 del GPIO del Raspberry Pi

Il pin E del display LCD è collegato al pin 24 del GPIO del Raspberry Pi

Il pin D4 del display LCD è collegato al pin 23 del GPIO del Raspberry Pi

Il pin D5 del display LCD è collegato al pin 17 del GPIO del Raspberry Pi

Il pin D6 del display LCD è collegato al pin 18 del GPIO del Raspberry Pi

Il pin D7 del display LCD è collegato al pin 22 del GPIO del Raspberry Pi

Il pin VSS del display LCD è collegato a terra del Raspberry Pi

Il pin VDD del display LCD è collegato al 3.3V del Raspberry Pi

Il pin V0 del display LCD è collegato al potenziometro

Il pin RS del display LCD è collegato al pin 25 del GPIO del Raspberry Pi

Il pin RW del display LCD è collegato a terra del Raspberry Pi

Tieni presente che i pin del sensore DHT22 e del display LCD possono variare a seconda del modello specifico che stai utilizzando, quindi assicurati di verificare la documentazione del produttore prima di effettuare i collegamenti.

…

che tipo di display hai ipotizzato di utilizzare?

…

Nel mio esempio di script Python per una stazione meteo su Raspberry Pi ho ipotizzato di utilizzare un display LCD compatibile con l’interfaccia HD44780. Questo è un tipo di display LCD molto comune che viene utilizzato in molti progetti DIY, è facile da trovare e a buon mercato. L’Adafruit_CharLCD library che ho utilizzato nel mio esempio di script supporta questo tipo di display e fornisce un’interfaccia semplice per la gestione del display.

Tieni presente che ci sono molte varianti di display LCD compatibili con l’interfaccia HD44780 e potrebbero essere necessarie alcune modifiche per l’utilizzo con questo script, soprattutto per quanto riguarda la configurazione dei pin di connessione.

Alziamo l’asticella

Abbiamo detto che ChatGPT è basato sul motore GPT-3 (GPT-4, molto più vasto e potente, è attualmente in sviluppo). GPT esiste già da qualche tempo, ma sconosciuto al grande pubblico, perché era accessibile solo via API, da un programma scritto per richiamarlo. Le API, in soldoni, sono un modo standard per fare richieste a un sistema e ottenere una risposta.

Quindi possiamo inserire le funzionalità di questa IA nei nostri programmi, interrogandola da remoto, in modo da avere il massimo della tecnologia ora disponibile e la potenza di calcolo dei server di OpenAI anche nei nostri piccoli Raspberry Pi? Certamente si!

E come si fa? Avrete capito, ormai, che il modo migliore di scoprirlo è semplicemente chiederlo a ChatGPT stessa!

crea una funzione python che, accettando in input una stringa di testo, la passi a chatGPT e stampi sullo schermo il risultato

…

Ecco un esempio di funzione che fa quello che hai chiesto:

import openai

def chat_with_gpt(prompt):
  openai.api_key = "YOUR_API_KEY" # Sostituisci "YOUR_API_KEY" con la tua API key di OpenAI
  model_engine = "text-davinci-002"

  completions = openai.Completion.create(
      engine=model_engine,
      prompt=prompt,
      max_tokens=1024,
      n=1,
      stop=None,
      temperature=0.7,
  )

  message = completions.choices[0].text
  return message

# Test della funzione
input_text = "Ciao, come va?"
print(chat_with_gpt(input_text))

import openai

def chat_with_gpt(prompt):

openai.api_key = "YOUR_API_KEY" # Sostituisci "YOUR_API_KEY" con la tua API key di OpenAI

model_engine = "text-davinci-002"

completions = openai.Completion.create(

engine=model_engine,

prompt=prompt,

max_tokens=1024,

n=1,

stop=None,

temperature=0.7,

)

message = completions.choices[0].text

return message

# Test della funzione

input_text = "Ciao, come va?"

print(chat_with_gpt(input_text))

Spero che questo esempio ti sia stato utile! Se hai altre domande, non esitare a chiedere.

Naturalmente serve avere una API key valida, da sostituire a YOUR_API_KEY qui su (si ottiene da qui https://openai.com/api/).

Le API sono a pagamento! Vi è un periodo di prova gratuito, di 3 mesi o 18$, in cui potrete però sperimentare. Perché sia attivo, dovrete però inserire un metodo di pagamento (o accedere con un account Google a cui sia abbinato un metodo di pagamento), perché esaurito il conto di prova, si paga a consumo (prezzi molto ragionevoli, comunque).

Assistente vocale intelligente

E se fondessimo l’esempio qui su per l’uso delle API di GPT-3 con quello della guida per far ascoltare a Python quel che diciamo in un microfono e rispondere con sintesi vocale? Se te la sei persa, qui c’è la relativa guida da leggere con attenzione:

Raspberry Pi ti ascolta, e risponde! Con Python

Beh, avremmo un assistente virtuale che accetta comandi vocali in linguaggio naturale e che risponde con sintesi vocale, che fa sembrare Siri, Alexa, e l’Assistente Google, dei pivellini!

Ecco qui, la modularità delle funzioni di Python mi ha reso decisamente semplice aggiungerla allo script precedente:

import speech_recognition as sp
import os, subprocess, openai
from gtts import gTTS

uscita_in = ["addio","esci"] #comandi vocali per terminare il programma

#definiamo le funzioni
def get_audio():           # ascolta dal microfono e manda a google per avere il testo
    r = sp.Recognizer()
    with sp.Microphone() as source:
        r.adjust_for_ambient_noise(source,duration=1)
        audio = r.listen(source)
        result = ""
        try:
            result = r.recognize_google(audio,language='it')
        except Exception:
            print("non ho capito")
    return result

def speak(text):          # crea un file audio e lo riproduce
    tts =gTTS(text=text,lang='it')
    filename = "voce.mp3"
    if os.path.exists(filename):
        os.remove(filename)
    tts.save(filename)
    subprocess.run(['mpg123', '-q', 'voce.mp3'])

def chat_with_gpt(prompt):    #interroga GPT e ne ha risposta
  openai.api_key = "YOUR_API_KEY" # Sostituisci "YOUR_API_KEY" con la tua API key di OpenAI
  model_engine = "text-davinci-002"

  completions = openai.Completion.create(
      engine=model_engine,
      prompt=prompt,
      max_tokens=512,
      n=1,
      stop=None,
      temperature=0.7,
  )

  message = completions.choices[0].text
  return message

#main

while True:                                 #ciclo infinito
    print('\r',"In ascolto...", end='')
    text_in = get_audio()            #ascolta una frase traducila con get_audio() e mettila in text_in
    text_in = text_in.lower()        #porta tutto minuscolo
    text_out = text_in
    if text_in!=None and text_in!="":        
        if text_in in uscita_in:
            print('\r', "a presto!           ", end='')
            quit()
        else:
            print('\r', "fammi pensare...", end='')
            try:
                text_out = (chat_with_gpt(text_in))
                speak(text_out)
            except errore:
                print('\r',"Si è verificato un errore!", end='')

import speech_recognition as sp

import os, subprocess, openai

from gtts import gTTS

uscita_in = ["addio","esci"] #comandi vocali per terminare il programma

#definiamo le funzioni

def get_audio(): # ascolta dal microfono e manda a google per avere il testo

r = sp.Recognizer()

with sp.Microphone() as source:

r.adjust_for_ambient_noise(source,duration=1)

audio = r.listen(source)

result = ""

try:

result = r.recognize_google(audio,language='it')

except Exception:

print("non ho capito")

return result

def speak(text): # crea un file audio e lo riproduce

tts =gTTS(text=text,lang='it')

filename = "voce.mp3"

if os.path.exists(filename):

os.remove(filename)

tts.save(filename)

subprocess.run(['mpg123', '-q', 'voce.mp3'])

def chat_with_gpt(prompt): #interroga GPT e ne ha risposta

openai.api_key = "YOUR_API_KEY" # Sostituisci "YOUR_API_KEY" con la tua API key di OpenAI

model_engine = "text-davinci-002"

completions = openai.Completion.create(

engine=model_engine,

prompt=prompt,

max_tokens=512,

n=1,

stop=None,

temperature=0.7,

)

message = completions.choices[0].text

return message

#main

while True: #ciclo infinito

print('\r',"In ascolto...", end='')

text_in = get_audio() #ascolta una frase traducila con get_audio() e mettila in text_in

text_in = text_in.lower() #porta tutto minuscolo

text_out = text_in

if text_in!=None and text_in!="":

if text_in in uscita_in:

print('\r', "a presto! ", end='')

quit()

else:

print('\r', "fammi pensare...", end='')

try:

text_out = (chat_with_gpt(text_in))

speak(text_out)

except errore:

print('\r',"Si è verificato un errore!", end='')

Per crearlo ho impiegato una manciata di minuti!! E funziona, Incredibile! (perché funzioni anche a te, devi prima installare le librerie che vengono importate all’inizio, e inserire la tua chiave API di OpenAI al posto di YOUR_API_KEY. Per farlo funzionare su un dispositivo che non ha microfono incorporato, come i Raspberry Pi, dovrai anche collegarne uno – USB o Bluetooth – trovare il suo device index e indicarlo nella riga 10 dello script qui su – vedi la guida “Raspberry Pi ti ascolta, e risponde! Con Python” linkata più in alto).

Ora, laniando il programma, si metterà in ascolto. Potrai usare la voce per porre una domanda, questa verrà tradotta in testo da speech_recognition, poi inviata a GPT-3, che elaborerà una risposta , e ce la rimanderà come testo. Quest’ultimo verrà inviato a Google con gtts perché venga trasformato in un file vocale, che verrà poi riprodotto da un player audio in modo che potremo ascoltare la risposta in vocale. Il tutto può richiedere qualche secondo, perché ultimamente GPT-3 è subissato di richieste. Per uscire, pronunciare “addio” o “esci”.

Conclusioni

Il codice ottenuto, a volte, va modificato, o ottimizzato, ma spesso è già perfettamente funzionante, se copiato su Thonny o direttamente sul vostro dispositivo. ChatGPT sostituisce un corso di programmazione? No, ma fa gran parte del lavoro e permette di partire in pochi secondi con una bozza, certo da ottimizzare, ma già quasi completa. inoltre, essendo in grado di rispondere in modo discorsivo e inerente al contesto, è un fantastico “assistente” di debug e di approfondimento. Potete postare il vostro codice e chiedere di aggiungere una funzione che aggiunga funzionalità, o come unire tra loro diversi programmi in linguaggi diversi e molto altro!

Usarlo per scrivere piccoli script come quelli che tipicamente si utilizzano su Raspberry Pi in molte applicazioni sperimentali, permette di fare un salto in avanti di produttività simile a quello che offre un trapano se devi effettuare dei buchi. Abbiamo un super potere!

Da un grande potere derivano grandi responsabilità

Se hai dubbi o sviluppi su questo tutorial, parliamone nella discussione dedicata sul forum.

Se vuoi restare aggiornato, seguici anche sui nostri social: Facebook, Twitter, Youtube

Se vuoi anche trovare prodotti e accessori Raspberry Pi in offerta, seguici anche su Telegram!!

RaspberryItaly Community Italiana