"Qualsiasi tecnologia sufficientemente avanzata è indistinguibile dalla magia." Arthur C. Clarke
Nel Rete neurale SBC dopo aver visto una rete di 1k pesi addestrata con 10k campioni per approssimare la funzione seno. In questo post utilizzeremo pesi da 175G allenati con campioni da 450G che possono programmare meglio del programmatore medio. Le dimensioni di questi modelli sono impressionanti, ma in realtà nessuno sa davvero come funzionano o quali sono i loro limiti.
GitHub Copilot è uno strumento di intelligenza artificiale che accelera lo sviluppo del software, consentendo al programmatore di fare molte cose che prima erano impossibili. All'inizio, sembra simile utilizzare StackOverflow, un sito Web in cui i programmatori inviano domande quando non sanno come fare qualcosa, ma Copilot va molto oltre, è in grado di sintetizzare una nuova risposta al nostro problema.
Copilot è incluso in un codice di Microsoft Visual Studio e suggerisce continuamente codici in grigio che puoi accettare premendo il pulsante di tabulazione. Questo codice suggerito può essere approssimativamente definito la corrispondenza "più comune" tra la tua query (il tuo codice) e il set di dati di addestramento (codice GitHub).
esempio 1

In questo esempio, definiamo la nostra funzione e la sua docstring e chiediamo il completamento a Copilot. Come vediamo, il completamento corrisponde alla docstring. La prima intuizione è che Copilot funge da motore di ricerca e abbina semplicemente la tua query al suo set di dati di addestramento (150 GB di progetti open source), ma non è così che funziona.
esempio 2

Qui creiamo una stringa casuale/pazza che non può essere nel set di allenamento. Il risultato sembra ancora essere la soluzione più coerente che può essere fornita, in questo caso: la somma dei parametri di input.
esempio 3

In questo esempio, chiediamo (in spagnolo) di sommare l'area di intersezione di due cerchi dati il suo centro e raggio. Copilot comprende il testo spagnolo senza problemi e suggerisce il nome della funzione, i parametri e tutto il corpo della funzione. Dopo una breve revisione sembra che il codice dovrebbe funzionare.
esempio 4

Ora creiamo un ipotetico testo di domanda/risposta. Questo fa sì che Copilot abbini la query ad alcuni esami che possono trovarsi in questo set di dati di formazione. Chiediamo semplicemente la capitale della Spagna e Copilot genera la risposta corretta.
esempio 5

Tuttavia, se chiediamo di un paese inesistente, Copilot dà anche la sua migliore risposta che sembra anche "corretta".
esempio 6

In questo esempio invertiamo il processo, diamo la risposta per provare a generare la domanda. Copilot genera una domanda che non ci aspettavamo. Ci aspettavamo 'Qual è la capitale della Francia?' e Copilot hanno chiesto "Qual è il risultato del seguente codice?" ma possiamo ancora capire un suggerimento corretto.
esempio 7

Qui costringiamo Copilot a chiedere cosa vogliamo cambiare in una lingua più comune e aggiungere la prima lettera. Tuttavia, genera un'altra domanda, questa volta completamente sbagliata e non ha alcuna relazione con la risposta.
In sintesi, Copilota:
- Crea un suggerimento basato sulla soluzione più comune.
- Di solito è corretto semplicemente se la tua domanda ha un senso.
- Di solito è sbagliato quando la tua query sembra un problema comune ma non lo è e in realtà ha un obiettivo molto diverso.
Copilot usando librerie open source
Copilot è stato formato con progetti open source. Include milioni di casi d'uso di qualsiasi libreria open source come numpy, opencv, qt... Questo rende Copilot davvero utile perché aiuta il programmatore con il suggerimento più comune che di solito è il migliore.
esempio 8

In questo esempio, usiamo il unittest python e Copilot sa che il unittest.TestCase ha un metodo chiamato assertEqual e lo sa anche pippo( 1, 2 ) dovrebbe essere 3.
esempio 9

Sopra ne creiamo uno più complesso foo funzione (che presumiamo non possa essere nei dati di addestramento), per vedere se Copilot comprende davvero il codice. Dopo aver eseguito il codice con 17 casi di test, solo 6 hanno fallito dando un tasso di successo del 65%.
Potrebbe non sembrare molto, ma tieni presente che Copilot non è un interprete python, non ha eseguito la funzione per ottenere il suo output ... Copilot ha utilizzato ciò che ha appreso durante l'allenamento per convertire la nostra query nell'output che ha una sintassi python perfetta e funziona bene anche il 65% delle volte.
esempio 10

Ci si potrebbe aspettare che un lungo testo di input provochi il fallimento di Copilot, ma non è così, più informazioni forniamo, migliori risposte può generare copilot.
Nell'esempio sopra chiediamo un compito complesso, un programma completo che richiede diverse comprensioni da risolvere, come: capacità di programmazione python, librerie specifiche di micropython e come usarle correttamente anche nella comprensione della descrizione del testo umano.
Il suggerimento completo viene visualizzato nella cella successiva. Si noti che corrisponde molto bene alla descrizione del programma. La classe dell'applicazione ha senso e anche le librerie di micropython (PIN, UART, ADC, PIN.irq...) vengono utilizzate correttamente. Non è perfetto al 100%, per esempio in questo caso temp_senor è un oggetto ADC, che non ha sensore_temp.init() metodo e altri piccoli errori possono essere generati, ma l'intera struttura del programma è decisamente corretta e i piccoli errori possono essere corretti facilmente.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | importare tempo importare macchina classe Applicazioni: def __init__(auto): auto.pulsante = macchina.Spillo(0, macchina.Pin.NEL) auto.sensore_temp = macchina.ADC(macchina.Spillo(1)) auto.uART = macchina.UART(1, 115200) auto.uART.dentro(115200, bit=8, parità=Nona, fermare=1) auto.ultimo_evento = 0 auto.ultima_temp = 0 auto.ultima volta = 0 auto.pulsante.irq(trigger=macchina.Pin.IRQ_FALLING, gestore=auto.pulsante_premuto) auto.pulsante.irq(trigger=macchina.Pin.IRQ_RISING, gestore=auto.pulsante_rilasciato) auto.sensore_temp.dentro() def pulsante_premuto(auto, spillo): auto.ultimo_evento = 1 auto.ultima volta = tempo.zecche_ms() auto.uART.scrivere (b'{},{},{}\n'.formato (auto.ultima volta, auto.ultimo_evento, auto.ultima_temp)) def pulsante_rilasciato(auto, spillo): auto.ultimo_evento = 0 auto.ultima volta = tempo.zecche_ms() auto.uART.scrivere (b'{},{},{}\n'.formato (auto.ultima volta, auto.ultimo_evento, auto.ultima_temp)) def leggi_temp(auto): auto.ultima_temp = auto.sensore_temp.read () auto.uART.scrivere (b'{},{},{}\n'.formato (auto.ultima volta, auto.ultimo_evento, auto.ultima_temp)) def eseguire il(auto): while I veri: auto.read_temp() ora.dormire(0.1) |
esempio 11
Infine, nell'esempio seguente utilizziamo Copilot per aggiungere i commenti al codice precedente. Copiamo la classe due volte e aggiungiamo alcune guide a Copilot come "Versione Docstring della classe sopra". Copilot genera la classe ei commenti per ogni riga.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 | # Versione Docstring della classe sopra classe Applicazioni: """ Breve: Questa è una semplice applicazione che legge il sensore di temperatura e invia i dati all'UART. I dati vengono inviati nel formato: tempo, evento, temp Il tempo è il tempo in millisecondi dall'inizio dell'applicazione. L'evento è 1 se si preme il pulsante e 0 se si rilascia il pulsante. La temperatura è la temperatura in gradi centigradi. "" " def __init__(auto): # Crea un oggetto pulsante auto.pulsante = macchina.Spillo(0, macchina.Pin.NEL) # Creare un oggetto sensore di temperatura auto.sensore_temp = macchina.ADC(macchina.Spillo(1)) # Crea un oggetto UART auto.uART = macchina.UART(1, 115200) # Inizializza l'oggetto UART auto.uART.dentro(115200, bit=8, parità=Nona, fermare=1) # Crea una variabile per memorizzare l'ultimo evento auto.ultimo_evento = 0 # Creare una variabile per memorizzare l'ultima temperatura auto.ultima_temp = 0 # Crea una variabile per memorizzare l'ultima volta auto.ultima volta = 0 # Registra il gestore dell'evento premuto sul pulsante auto.pulsante.irq(trigger=macchina.Pin.IRQ_FALLING, gestore=auto.pulsante_premuto) # Registra il gestore dell'evento rilasciato dal pulsante auto.pulsante.irq(trigger=macchina.Pin.IRQ_RISING, gestore=auto.pulsante_rilasciato) # Inizializzare il sensore di temperatura auto.sensore_temp.dentro() def pulsante_premuto(auto, spillo): # Imposta l'ultimo evento su 1 auto.ultimo_evento = 1 # Impostare l'ultima volta sull'ora corrente auto.ultima volta = tempo.zecche_ms() # Invia l'ultima volta, l'ultimo evento e l'ultima temperatura all'UART auto.uART.scrivere (b'{},{},{}\n'.formato (auto.ultima volta, auto.ultimo_evento, auto.ultima_temp)) def pulsante_rilasciato(auto, spillo): # Imposta l'ultimo evento su 0 auto.ultimo_evento = 0 # Impostare l'ultima volta sull'ora corrente auto.ultima volta = tempo.zecche_ms() # Invia l'ultima volta, l'ultimo evento e l'ultima temperatura all'UART auto.uART.scrivere (b'{},{},{}\n'.formato (auto.ultima volta, auto.ultimo_evento, auto.ultima_temp)) def leggi_temp(auto): # Impostare l'ultima temperatura sulla temperatura attuale auto.ultima_temp = auto.sensore_temp.read () # Invia l'ultima volta, l'ultimo evento e l'ultima temperatura all'UART auto.uART.scrivere (b'{},{},{}\n'.formato (auto.ultima volta, auto.ultimo_evento, auto.ultima_temp)) def eseguire il(auto): while I veri: # Leggi la temperatura auto.leggi_temp() # Attendi 0.1 secondi tempo.dormire(0.1) |