Che cosa è la Generative AI?
La Generative AI, o Intelligenza Artificiale Generativa, è un campo dell'intelligenza artificiale che si concentra sulla creazione di modelli in grado di generare nuovi contenuti originali, come immagini, testo, musica e altro ancora.
A differenza degli approcci tradizionali dell'AI, che si concentrano sulla risoluzione di compiti specifici, la Generative AI mira a produrre output autonomamente e in modo creativo, simile a quanto fatto dagli esseri umani. La Generative AI utilizza algoritmi di apprendimento automatico per imparare dai dati esistenti e creare modelli probabilistici che possano generare nuovi esempi che assomiglino al dataset di addestramento. Questi modelli sono in grado di apprendere le distribuzioni di probabilità dei dati di input e generarne di nuovi campioni che rispettano queste distribuzioni.
Quali sono le tue opinioni sulla generative AI?
Penso che sia un'innovazione sorprendente e promettente;
Credo che possa aprire nuove possibilità creative;
Sono preoccupato per possibili abusi o manipolazioni;
Non ho ancora una posizione definita sulla generative Ai;
Casi d'uso della Generative AI:
Generazione di immagini: La Generative AI può essere utilizzata per generare immagini realistiche da zero o per completare immagini esistenti. Questo può essere utile in campi come la grafica e il design, la produzione di contenuti visivi per videogiochi o la sintesi di dati per l'addestramento di reti neurali.
Creazione di testo: I modelli generativi possono essere addestrati su grandi quantità di testo per generare automaticamente nuovi articoli, poesie, storie o persino codice sorgente. Ciò può essere utile per la generazione di contenuti creativi, l'automazione della scrittura o l'assistenza nell'elaborazione del linguaggio naturale.
Composizione musicale: La Generative AI può essere impiegata per creare nuove composizioni musicali in vari generi, stili e strumentazioni. I modelli possono apprendere da una vasta gamma di brani esistenti per generare melodie, armonie e arrangiamenti originali.
Simulazione e creazione di personaggi: La Generative AI può essere utilizzata per generare personaggi virtuali, come avatars o NPC (personaggi non giocanti) per videogiochi o ambienti di realtà virtuale. Questi modelli possono apprendere dalle caratteristiche fisiche e comportamentali degli esseri umani per creare personaggi virtuali credibili e interattivi.
Modifica e miglioramento di immagini: I modelli generativi possono essere impiegati per modificare o migliorare immagini esistenti, come rimozione di rumore, riscalatura, colorazione automatica o restauro di immagini danneggiate.
Generazione di video e animazioni: La Generative AI può essere utilizzata per creare sequenze di video e animazioni. Ad esempio, è possibile generare nuovi frame intermedi tra due frame di partenza o creare nuove animazioni a partire da un insieme di esempi di movimento.
Questi sono solo alcuni esempi di come la Generative AI possa essere applicata in vari campi. Con il continuo sviluppo delle tecniche di apprendimento automatico e l'aumento delle capacità computazionali, le possibilità della Generative AI stanno crescendo, aprendo nuove opportunità creative e innovative.
Python
Python è un linguaggio di programmazione ad alto livello, interpretato e orientato agli oggetti. È noto per la sua sintassi semplice e leggibile, che favorisce la scrittura di codice chiaro e conciso. Python è stato creato da Guido van Rossum e il suo sviluppo iniziò nel 1989. Da allora, è diventato uno dei linguaggi più popolari al mondo, utilizzato in una vasta gamma di applicazioni e settori.
Ecco alcune caratteristiche e vantaggi di Python:
Sintassi semplice: La sintassi di Python è progettata per essere facile da leggere e scrivere, con un focus sulla leggibilità del codice. Questo rende Python un linguaggio ideale sia per i principianti che per i professionisti.
Ampia libreria standard: Python include una vasta libreria standard che offre funzionalità per una varietà di compiti, come manipolazione di stringhe, gestione di file, networking e molto altro. Questa ricca libreria semplifica lo sviluppo di progetti complessi, riducendo la necessità di scrivere codice da zero.
Community attiva: Python ha una comunità di sviluppatori molto attiva e collaborativa. Questo si traduce in una vasta quantità di risorse, documentazione e librerie di terze parti disponibili gratuitamente, che facilitano l'apprendimento e l'implementazione di progetti.
Versatilità: Python è un linguaggio versatile che può essere utilizzato in diversi ambiti, come lo sviluppo web, l'analisi dei dati, l'intelligenza artificiale, l'automazione di processi, il networking e molto altro ancora. Questa flessibilità consente agli sviluppatori di utilizzare Python in vari contesti.
Integrazione con altri linguaggi: Python può essere facilmente integrato con altri linguaggi come C, C++, Java e .NET. Ciò consente agli sviluppatori di utilizzare librerie specializzate esistenti in altri linguaggi o di ottimizzare parti di un'applicazione scrivendo codice in linguaggi più performanti.
Piattaforme multiple: Python è supportato su diverse piattaforme, tra cui Windows, macOS e Linux. Questa portabilità consente agli sviluppatori di scrivere applicazioni una volta e eseguirle su diverse piattaforme senza dover apportare modifiche significative al codice.
Apprendimento e comunità: Python è ampiamente utilizzato nel settore dell'istruzione e viene considerato un linguaggio ideale per i principianti nella programmazione. Ci sono molti tutorial, corsi online e risorse di apprendimento disponibili per chiunque desideri imparare Python.
Python continua a guadagnare popolarità grazie alla sua facilità d'uso, alla sua vasta comunità di sviluppatori e alla sua flessibilità. È un linguaggio potente che offre numerose opportunità per sviluppatori, ricercatori, data scientist e professionisti di molti settori.
Generative AI con Python: Casi d'utilizzo
Possono essere creati molti modelli di generative AI utilizzando la libreria Python tensorflow, ecco alcuni esempi:
Un semplice modello di rete neurale LSTM utilizzando la libreria tensorflow.keras. Vengono creati dati di addestramento con una serie di parole (training_data) e viene costruito un dizionario di caratteri unici presenti in questi dati. Successivamente, i dati di addestramento vengono preparati creando sequenze di input (input_sequences) e sequenze di output (target_sequences). I dati vengono quindi convertiti in formato one-hot encoding utilizzando la funzione tf.one_hot.
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM
# Creazione dei dati di addestramento
training_data = ['ciao', 'come', 'va', 'oggi']
corpus = ' '.join(training_data)
# Creazione del dizionario dei caratteri
chars = sorted(list(set(corpus)))
char_to_num = {char: num for num, char in enumerate(chars)}
num_to_char = {num: char for num, char in enumerate(chars)}
# Preparazione dei dati di addestramento
input_sequences = []
target_sequences = []
seq_length = 3
for i in range(len(corpus) - seq_length):
input_seq = corpus[i:i + seq_length]
target_seq = corpus[i + seq_length]
input_sequences.append([char_to_num[char] for char in input_seq])
target_sequences.append(char_to_num[target_seq])
# Conversione dei dati in formato one-hot encoding
X = tf.one_hot(input_sequences, len(chars))
y = tf.one_hot(target_sequences, len(chars))
# Creazione del modello LSTM
model = Sequential()
model.add(LSTM(128, input_shape=(seq_length, len(chars))))
model.add(Dense(len(chars), activation='softmax'))
# Compilazione del modello
model.compile(loss='categorical_crossentropy', optimizer='adam')
# Addestramento del modello
model.fit(X, y, epochs=100, batch_size=16)
# Generazione di nuovi dati
seed = 'cia'
for _ in range(10):
x_pred = tf.one_hot([[char_to_num[char] for char in seed]], len(chars))
prediction = model.predict(x_pred)
char_index = tf.argmax(prediction, axis=1).numpy()[0]
result_char = num_to_char[char_index]
seed += result_char
seed = seed[1:]
print(result_char, end='')
Un modello LSTM (Long Short-Term Memory) per generare testo basato su dati di addestramento predefiniti. Il testo generato parte da un'input seed ("Lorem ipsum") e genera 10 parole successive utilizzando il modello addestrato.
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM, Embedding
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
# Dati di addestramento
text_data = [
"Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
"Sed ut perspiciatis unde omnis iste natus error sit voluptatem.",
"At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis.",
"Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit.",
"Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur."
]
# Tokenizzazione del testo
tokenizer = Tokenizer()
tokenizer.fit_on_texts(text_data)
total_words = len(tokenizer.word_index) + 1
input_sequences = []
for line in text_data:
token_list = tokenizer.texts_to_sequences([line])[0]
for i in range(1, len(token_list)):
n_gram_sequence = token_list[:i+1]
input_sequences.append(n_gram_sequence)
# Padding delle sequenze di input
max_sequence_len = max([len(seq) for seq in input_sequences])
input_sequences = pad_sequences(input_sequences, maxlen=max_sequence_len, padding='pre')
# Creazione degli array di input e output
input_sequences = tf.convert_to_tensor(input_sequences)
x_train = input_sequences[:, :-1]
y_train = tf.keras.utils.to_categorical(input_sequences[:, -1], num_classes=total_words)
# Creazione del modello
model = Sequential()
model.add(Embedding(total_words, 100, input_length=max_sequence_len-1))
model.add(LSTM(150))
model.add(Dense(total_words, activation='softmax'))
# Compilazione e addestramento del modello
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(x_train, y_train, epochs=100, verbose=1)
# Funzione per generare testo
def generate_text(seed_text, next_words, model, max_sequence_len):
for _ in range(next_words):
token_list = tokenizer.texts_to_sequences([seed_text])[0]
token_list = pad_sequences([token_list], maxlen=max_sequence_len-1, padding='pre')
predicted = model.predict_classes(token_list, verbose=0)
output_word = ""
for word, index in tokenizer.word_index.items():
if index == predicted:
output_word = word
break
seed_text += " " + output_word
return seed_text
# Generazione di testo
generated_text = generate_text("Lorem ipsum", 10, model, max_sequence_len)
print(generated_text)
[OUT]
Lorem ipsum dolor sit amet consectetur adipiscing elit elit esse cillum doloreIn questo esempio, utilizzeremo il dataset MNIST per addestrare un modello generativo che genera nuovi dati simili a quelli presenti nel dataset. Il modello utilizza una rete neurale con layer densi per generare nuove immagini. Si noti che questo esempio è solo una dimostrazione generale di come potrebbe essere creato un modello di Generative AI in Python utilizzando TensorFlow. I dettagli specifici del modello dipenderanno dal tipo di generazione desiderata (immagini, testo, musica, ecc.) e dai dati disponibili per l'addestramento.
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM
# Definisci il numero di caratteri da generare
num_caratteri = 100
# Carica il dataset di addestramento
dataset = tf.keras.datasets.mnist
(x_train, _), (_, _) = dataset.load_data()
x_train = x_train.reshape(-1, 28*28) / 255.0# Crea il modello
model = Sequential()
model.add(Dense(256, input_shape=(28*28,), activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(28*28, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam')
# Addestra il modello
model.fit(x_train, x_train, epochs=10, batch_size=128)
# Genera nuovi dati
nuovi_dati = model.predict(x_train[:1])
nuovi_dati = nuovi_dati.reshape((28, 28)) * 255.0
nuovi_dati = nuovi_dati.astype('uint8')
# Stampa i dati generati
print(nuovi_dati)
import matplotlib.pyplot as plt
%matplotlib inline
# plot the sample
fig = plt.figure
plt.imshow(nuovi_dati, cmap='gray')
plt.show()
In questo esempio, è stata creata una rete neurale generativa semplice con tre strati densamente connessi e un layer di output che rappresenta un'immagine 28x28 pixel in scala di grigi. L'input per il generatore è un rumore casuale di dimensione 100. Si ultilizzerà quindi il generatore per generare un'immagine utilizzando il rumore casuale come input. La dimensione dell'immagine generata sarà stampata a schermo. Nota che questo esempio crea solo un'immagine generata utilizzando il generatore. In un'applicazione pratica, ad esempio nell'addestramento di una rete generativa avversaria (GAN), il generatore verrebbe addestrato insieme al discriminatore per produrre immagini realistiche.
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
# Definisci la rete neurale generativa
generator = keras.Sequential(
[
layers.Dense(256, input_shape=(100,), activation="relu"),
layers.Dense(512, activation="relu"),
layers.Dense(784, activation="tanh"),
layers.Reshape((28, 28)),
],
name="generator"
)
# Crea un rumore casuale come input per il generatore
noise = tf.random.normal(shape=(1, 100))
# Genera un'immagine utilizzando il generatore
generated_image = generator(noise, training=False)
# Stampa le dimensioni dell'immagine generata
print(generated_image.shape)
import matplotlib.pyplot as plt
%matplotlib inline
# plot the sample
fig = plt.figure
plt.imshow(generated_image[0,:,:], cmap='gray')
plt.show()
Questo è solo un semplice esempio di un modello generativo basato su GAN (Generative Adversarial Networks) utilizzando il dataset MNIST per generare immagini di cifre scritte a mano. Il codice addestra il generatore e il discriminatore alternativamente per cercare di migliorare le prestazioni del generatore nel generare immagini realistiche.
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.datasets import mnist
import numpy as np
import matplotlib.pyplot as plt
# Carica il dataset MNIST
(x_train, _), (_, _) = mnist.load_data()
# Normalizza le immagini
x_train = x_train.astype('float32') / 255.0
x_train = np.reshape(x_train, (len(x_train), 784))
# Definisci il generatore
generator = Sequential()
generator.add(Dense(256, input_dim=100, activation='relu'))
generator.add(Dense(512, activation='relu'))
generator.add(Dense(784, activation='sigmoid'))
# Definisci il discriminatore
discriminator = Sequential()
discriminator.add(Dense(512, input_dim=784, activation='relu'))
discriminator.add(Dropout(0.3))
discriminator.add(Dense(256, activation='relu'))
discriminator.add(Dropout(0.3))
discriminator.add(Dense(1, activation='sigmoid'))
# Compila il generatore
generator.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0002, beta_1=0.5))
# Compila il discriminatore
discriminator.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0002, beta_1=0.5), metrics=['accuracy'])
# Combina il generatore e il discriminatore in un unico modello
discriminator.trainable = False
gan_input = tf.keras.Input(shape=(100,))
generated_image = generator(gan_input)
gan_output = discriminator(generated_image)
gan = tf.keras.Model(gan_input, gan_output)
gan.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0002, beta_1=0.5))
# Funzione per addestrare il generatore e il discriminatore
def train_gan(epochs, batch_size, sample_interval):
for epoch in range(epochs):
# Addestra il discriminatore
real_images = x_train[np.random.randint(0, x_train.shape[0], size=batch_size)]
real_labels = np.ones((batch_size, 1))
fake_images = generator.predict(np.random.normal(0, 1, (batch_size, 100)))
fake_labels = np.zeros((batch_size, 1))
discriminator_loss_real = discriminator.train_on_batch(real_images, real_labels)
discriminator_loss_fake = discriminator.train_on_batch(fake_images, fake_labels)
discriminator_loss = 0.5 * np.add(discriminator_loss_real, discriminator_loss_fake)
# Addestra il generatore
noise = np.random.normal(0, 1, (batch_size, 100))
generator_loss = gan.train_on_batch(noise, np.ones((batch_size, 1)))
# Stampa le metriche di addestramento
if epoch % sample_interval == 0:
print(f'Epoch: {epoch}, Discriminator Loss: {discriminator_loss[0]}, Generator Loss: {generator_loss}')
# Genera e salva immagini generate
save_generated_images(epoch)
# Funzione per generare e salvare le immagini generate
def save_generated_images(epoch):
r, c = 5, 5
noise = np.random.normal(0, 1, (r * c, 100))
generated_images = generator.predict(noise)
generated_images = generated_images * 255.0
generated_images = generated_images.reshape(r * c, 28, 28).astype(np.uint8)
fig, axs = plt.subplots(r, c)
cnt = 0
for i in range(r):
for j in range(c):
axs[i, j].imshow(generated_images[cnt, :, :], cmap='gray')
axs[i, j].axis('off')
cnt += 1
fig.savefig(f'generated_images_{epoch}.png')
plt.close()
# Addestra il modello
train_gan(epochs=1000, batch_size=32, sample_interval=1000)
A 0-epochs
Dopo 1000-epochs
Conclusione
Le tecnologie di generative AI hanno raggiunto livelli di complessità notevoli negli ultimi anni, grazie all'avanzamento delle reti neurali e dell'apprendimento automatico. Modelli come le reti generative avversarie (GAN) e i modelli di linguaggio trasformer hanno dimostrato la loro capacità di generare contenuti realistici e convincenti, superando in alcuni casi l'abilità umana.
L'applicazione pratica della generative AI è diversificata e coinvolge diversi settori, tra cui l'arte, il design, l'intrattenimento, la simulazione e persino l'ottimizzazione di processi industriali. Queste tecnologie hanno aperto nuove possibilità creative, consentendo a designer, artisti e ricercatori di esplorare territori inesplorati e di creare nuove esperienze.
Tuttavia, la generative AI solleva anche importanti questioni etiche e legali, come la protezione dei diritti d'autore, la manipolazione delle informazioni e la privacy. È necessario sviluppare meccanismi di regolamentazione e controllo per garantire un utilizzo responsabile di queste tecnologie e prevenire abusi.
In definitiva, la generative AI rappresenta un ambito promettente che ha il potenziale per rivoluzionare molti settori e aprire nuovi orizzonti creativi. Continuerà a evolversi e a crescere, portando a ulteriori innovazioni e sfide che richiederanno l'impegno di esperti e della società nel suo complesso per affrontarle in modo adeguato.
Comments