Trasformazione di testo in video: Azure Open AI, servizi cognitivi e kernel semantico (Python) (2023)

Bentornati alla seconda parte del nostro viaggio nel mondo di Azure e OpenAI! Nella prima parte abbiamo esplorato come trasformare il testo in video utilizzando le potenti funzionalità di intelligenza artificiale di Azure. Questa volta stiamo facendo un ulteriore passo avanti orchestrando il flusso della nostra applicazione con Semantic Kernel.

Il kernel semantico è un potente strumento che ci consente di comprendere e manipolare il significato del testo in modo più sfumato. Utilizzando Semantic Kernel, possiamo creare flussi di lavoro più sofisticati e generare risultati più significativi dal nostro processo di trasformazione da testo a video.

In questa parte della serie, ci concentreremo su come il kernel semantico può migliorare la nostra applicazione e fornire un flusso di lavoro più fluido ed efficiente. Approfondiremo le sue funzionalità, esploreremo i suoi vantaggi e ti mostreremo come può rivoluzionare il tuo processo di trasformazione da testo a video.

Un cambiamento fondamentale nel nostro approccio questa volta è saltare la fase di riconoscimento dell'entità dell'ultimo blog. Dopo un'attenta considerazione, abbiamo scoperto che non è necessario per il nostro flusso di lavoro attuale. Questa decisione ci consente di semplificare il nostro processo e concentrarci su ciò che conta veramente: creare contenuti video di alta qualità dal testo.

Quindi, allacciatevi le cinture e preparatevi per un emozionante viaggio nel mondo di Semantic Kernel e Azure! Immergiamoci.

Se vuoi controllare il mio vecchio post su questo argomento, non esitare a controllarloQui.

La parte successiva delle sezioni spiegherà il flusso e l'implementazione attraverso la codifica Python attraverso le orchestrazioni del kernel semantico. Se sei nuovo a queste tecnologie, non preoccuparti, consulta questi collegamenti prerequisiti per iniziare:

1. IA aperta di Azure:Inizia a utilizzare il servizio Azure OpenAI: formazione | Microsoft Impara
   • Utilizzeremo i modelli di completamento di Azure OpenAI e non i modelli di chat. Quindi, utilizza il modello Azure Open AI GPT 3.5 Turbo (0301) per questo.
2. Servizi cognitivi di Azure:
   • Discorso al testo:Panoramica della sintesi vocale - Servizio vocale - Servizi cognitivi di Azure | Microsoft Impara
3. Codifica Python: troverai più corsi su Internet a cui puoi fare riferimentoImpara Python: tutorial interattivo gratuito su Python
4. Orchestrazioni del kernel semantico:Orchestra la tua intelligenza artificiale con il kernel semantico | Microsoft Impara

Ora creeremo il nostro file di ambiente, puoi chiamarlo .env. Si prega di compilare i dettagli nel file nel formato seguente:

AZURE_OPENAI_DEPLOYMENT_NAME=""AZURE_OPENAI_ENDPOINT=""AZURE_OPENAI_API_KEY=""SPEECH_KEY=""SPEECH_REGION=""DALLE_API_BASE= ""DALLE_API_KEY=""DALLE_API_VERSION=""

Se si usa AzureOpenAI e DALL-E entrambi nella stessa risorsa, AZURE_OPENAI_ENDPOINT e AZURE_OPENAI_API_KEY saranno gli stessi per DALLE_API_BASE e DALLE_API_KEY.

Spiegazione delle variabili:

Il codice sopra è un file di configurazione scritto nel formato dotenv. Contiene diverse variabili di ambiente utilizzate per configurare varie API e servizi.

Le prime tre variabili di ambiente sono correlate all'API OpenAI. La variabileAZURE_OPENAI_DEPLOYMENT_NAME specifica il nome della distribuzione utilizzata per ospitare il modello GPT Turbo Completion. La variabileAZURE_OPENAI_ENDPOINT specifica l'URL dell'endpoint per l'API OpenAI. Infine, la variabileAZURE_OPENAI_API_KEY contiene la chiave API utilizzata per autenticare le richieste all'API OpenAI.

Le due variabili di ambiente successive sono correlate all'API dei servizi vocali di Azure. La variabile SPEECH_KEY contiene la chiave API utilizzata per autenticare le richieste all'API dei servizi vocali. La variabile SPEECH_REGION specifica l'area in cui è ospitata l'API dei servizi vocali.

Le ultime tre variabili di ambiente sono correlate all'API DALL-E, che è un'altra API OpenAI. La variabile DALLE_API_BASE specifica l'URL di base per l'API DALL-E. La variabile DALLE_API_KEY contiene la chiave API utilizzata per autenticare le richieste all'API DALL-E. Infine, la variabile DALLE_API_VERSION specifica la versione dell'API DALL-E utilizzata.

Nel complesso, questo file di configurazione viene utilizzato per archiviare informazioni riservate e impostazioni di configurazione utilizzate dall'applicazione. Utilizzando le variabili di ambiente, l'applicazione può accedere facilmente a queste informazioni senza doverle inserire nel codice sorgente.

Per migliorare la leggibilità di questo codice, potrebbe essere utile raggruppare insieme le variabili di ambiente correlate e aggiungere commenti che spieghino lo scopo per cui viene utilizzata ciascuna variabile. Inoltre, potrebbe essere utile utilizzare uno strumento come dotenv-linter per garantire che il file sia formattato correttamente e che non siano presenti errori di sintassi.

Ora suggerirò una struttura di cartelle per questa applicazione. Non è obbligatorio seguirlo.

Ho creato 4 cartelle per questa applicazione.

• Audio: cartella in cui archiviare l'audio generato dal servizio vocale di Azure
• Immagini: cartella per archiviare le mie immagini generate dalle chiamate API DALL-E
• myPlugins: cartella in cui conservare tutti i miei plugin per questa applicazione.
• Video: cartella in cui archiviare il mio video finale da questa applicazione.

I plugin del kernel semantico fungono da funzioni modulari meticolosamente realizzate dagli sviluppatori per migliorare le capacità dei sistemi di intelligenza artificiale. Queste unità versatili incapsulano le funzionalità dell'intelligenza artificiale, costituendo i componenti fondamentali dell'architettura del kernel semantico. Interagiscono perfettamente con i plug-in di ChatGPT, Bing e Microsoft 365, favorendo un ecosistema armonioso di innovazione dell'intelligenza artificiale.

Questi plugin si distinguono per due tipologie di funzioni distinte:

• Funzioni semantiche: Si tratta di prompt dinamici intrecciati con variabili contestuali. Gestiscono principalmente input e output testuali, funzionando come canali per interazioni sfumate con il sistema di intelligenza artificiale.
• Funzioni native: Queste funzioni, sebbene integrali, rimangono non elaborate nei risultati di ricerca, ma contribuiscono in modo significativo al repertorio dei plugin.

Inoltre, il kernel semantico vanta una serie di plugin predefiniti su misura per diversi linguaggi di programmazione. Questi plugin fondamentali, comunemente indicati come plugin Core, esemplificano l'utilità completa del kernel semantico. Alcuni di questi plugin Core, attualmente accessibili all'interno del framework Semantic Kernel, comprendono:

• ConversazioneRiepilogoAbilità: Riassumendo brevemente i dialoghi.
• FileIOSkill: Facilitare le interazioni del filesystem per la lettura e la scrittura.
• HttpSkill: Abilitazione delle chiamate API continue.
• Abilità matematica: Potenziare i calcoli matematici.
• TextMemorySkilll: Memorizzazione e recupero di testo dalla memoria.
• Abilità di testo: Garantire la manipolazione deterministica delle stringhe di testo.
• TimeSkill: ottenere informazioni temporali, tra cui l'ora del giorno e i relativi dettagli.
• WaitSkilll: sospensione temporanea dell'esecuzione per intervalli definiti.

Questi plugin Core si integrano perfettamente nei tuoi progetti, supportando un'importazione semplice e una facile concatenazione. Ad esempio, ilAbilità di testooffre una sequenza continua di operazioni, dal taglio degli spazi bianchi alla conversione in maiuscolo, quindi alla transizione in minuscolo: un esempio illustrativo della sinergia dei plugin in gioco.

In questa applicazione creeremo tutti i nostri plugin da zero. Sarà una combinazione di funzioni semantiche e funzioni native. La tabella seguente fornirà maggiori dettagli sui plugin.

Riepiloga il plugin

Per il plugin Summarize, crea una nuova cartella denominata summaryPlugin all'interno della cartella myPlugins.

Crea altri due file lì:

1. config.json
2. skprompt.txt

In config.json aggiungi il seguente contenuto:

{ "schema": 1, "description": "Riassumi il contenuto", "type": "completion", "completion": { "max_tokens": 1000, "temperature": 0, "top_p": 0, "presence_penalty ": 0.0, "frequency_penalty": 0.0 }, "input": { "parameters": [ { "name": "input", "description": "Riassumi il contenuto", "defaultValue": "" } ] } }

Nel file skprompt.txt:

{{$input}}Riassumi il contenuto in meno di 100 parole.Riepilogo:

Plug-in audio

Per il plugin audio, crea una nuova cartella denominata audioPlugin all'interno della cartella myPlugins.

Crea un nuovo file denominato audioPlugin.py

import azure.cognitiveservices.speech as Speechsdkfrom semantic_kernel.skill_definition import ( sk_function, sk_function_context_parameter,)from semantic_kernel.orchestration.sk_context import SKContextclass AudioPlugin: _function( description="Crea un file audio con il contenuto specificato", name="create_audio_file", input_description ="Il contenuto da convertire in audio", ) _function_context_parameter( name="content", description="Il contenuto da convertire in audio", ) _function_context_parameter( name="speech_key", description="speech_key", ) _function_context_parameter( name="speech_region", description="speech_region", ) def create_audio_file(self, contesto: SKContext): Speech_config = Speechsdk.SpeechConfig(subscription=context["speech_key"], Region=context["speech_region"]) content = contesto ["content"] nomefile = "Audio/audio.mp4" audio_config = Speechsdk.AudioConfig(filename=nomefile) Speech_synthesizer = Speechsdk.SpeechSynthesizer(speech_config=speech_config, audio_config=audio_config) risultato = Speech_synthesizer.speak_text_async(content).get() if result.reason == Speechsdk.ResultReason.SynthesizingAudioCompleted: print(f"Audio salvato in {filename}") else: print(f"Errore: {result.error_details}") print("File audio creato..... ")

Spiegazione del codice:

Il codice sopra definisce una classe Python chiamata AudioPlugin che contiene un singolo metodo chiamato create_audio_file. Questo metodo è decorato con diversisk_function_context_parameterdecorators che definiscono i parametri di input per la funzione.

Il metodo create_audio_file accetta un singolo parametro di input chiamato contesto, che è un'istanza della classe SKContext. Questa classe è definita in un altro modulo e fornisce un modo per passare informazioni di contesto tra diverse parti dell'applicazione.

All'interno del metodo create_audio_file, la prima cosa che accade è che un oggetto SpeechConfig viene creato utilizzando i parametri speech_key e speech_region dall'oggetto contesto. Questo oggetto viene utilizzato per configurare il servizio di sintesi vocale che verrà utilizzato per convertire il testo in audio.

Successivamente, il parametro content dall'oggetto contesto viene recuperato e archiviato in una variabile. Questo contenuto verrà convertito in audio nel passaggio successivo.

Successivamente, viene specificato un nome file per il file audio di output. Questo file verrà salvato nella directory Audio con il nome audio.mp4.

Viene quindi creato un oggetto AudioConfig utilizzando il nome file specificato nel passaggio precedente. Questo oggetto consente di configurare le impostazioni dell'uscita audio per il servizio di sintesi vocale.

Infine, viene creato un oggetto SpeechSynthesizer utilizzando gli oggetti SpeechConfig e AudioConfig. Questo oggetto viene utilizzato per sintetizzare l'audio dal testo di input. Il metodo Speak_text_asyncm viene richiamato sull'oggetto SpeechSynthesizer con il parametro content come input. Il metodo get viene quindi richiamato sul risultato di questo metodo per attendere il completamento della sintesi audio.

Se la sintesi audio ha esito positivo, il file audio risultante viene salvato con il nome file specificato e viene stampato un messaggio sulla console che indica che il file audio è stato creato. Se si verifica un errore durante il processo di sintesi audio, viene invece stampato un messaggio di errore sulla console.

Nel complesso, questo codice definisce una classe che può essere usata per creare file audio da testo usando l'API di Servizi vocali di Azure. Utilizzando la classe SKContext per passare le informazioni di configurazione necessarie, questa classe può essere facilmente integrata in altre parti dell'applicazione.

Plug-in Prompt

Per il Prompt Plugin, crea una nuova cartella denominata promptPlugin all'interno della cartella myPlugins.

Crea altri due file lì:

1. config.json
2. skprompt.txt

In config.json aggiungi il seguente contenuto:

{ "schema": 1, "description": "Crea Dalle idee prompt", "type": "completion", "completion": { "max_tokens": 1000, "temperature": 0.9, "top_p": 0, " Presence_penalty": 0.0, "frequency_penalty": 0.0 }, "input": { "parameters": [ { "name": "input", "description": "Crea idee prompt Dalle", "defaultValue": "" } ] } }

Nel file skprompt.txt:

crea 10 suggerimenti immagine dall-e sul contenuto seguente{{$input}}Richiesti:

Plug-in per immagini

Per Image Plugin, crea una nuova cartella denominata imagePlugin all'interno della cartella myPlugins.

Crea un nuovo file denominato imagePlugin.py

import requestimport timeimport urllib.requestfrom semantic_kernel.skill_definition import ( sk_function, sk_function_context_parameter,)from semantic_kernel.orchestration.sk_context import SKContextclass ImagePlugin: _function( description="Crea immagini con i prompt specificati", name="create_image_files", input_description="Il contenuto da convertire in immagini", ) _function_context_parameter( name="prompts", description="Il contenuto da convertire in immagini", ) _function_context_parameter( name="api_base", description="api_base", ) _function_context_parameter( name="api_key ", description="api_key", ) _function_context_parameter( name="api_version", description="api_version", ) def create_image_files(self, context: SKContext): api_base = context["api_base"] api_key = context["api_key"] api_version = context["api_version"] url = "{}dalle/text-to-image?api-version={}".format(api_base, api_version) headers= { "api-key": api_key, "Content-Type ": "application/json" } immagini = [] contatore = 0 elenco_immagini = [] for frase nel contesto["prompts"]: print("Immagine per: ",frase) corpo = { "didascalia": frase , "risoluzione ": "1024x1024" } submission = request.post(url, headers=headers, json=body) operazione_location = submission.headers['Operation-Location'] retry_after = submission.headers['Retry-after'] status = "" # while (status!= "Succeeded"): time.sleep(int(retry_after)) risposta = request.get(operazione_location, headers=headers) status = risposta.json()['status'] #print(status) if status == "Riuscito": contatore += 1 image_url = risposta.json()['result']['contentUrl'] nomefile = "Immagini/file" + str(contatore) + ".jpg" urllib.request.urlretrieve (URL_immagine, nome file)

Spiegazione del codice:

Il codice sopra definisce una classe Python chiamata ImagePlugin che contiene un singolo metodo chiamato create_image_files. Questo metodo è decorato con diversisk_function_context_parameterdecorators che definiscono i parametri di input per la funzione.

Il metodo create_image_files accetta un singolo parametro di input chiamato contesto, che è un'istanza della classe SKContext. Questa classe è definita in un altro modulo e fornisce un modo per passare informazioni di contesto tra diverse parti dell'applicazione.

All'interno del metodo create_image_files, diverse variabili vengono inizializzate utilizzando i valori dell'oggetto contesto. Queste variabili includono i parametri api_base, api_key e api_version, utilizzati per configurare l'API DALL-E che verrà utilizzata per generare le immagini.

Successivamente, viene avviato un ciclo che ripete ogni prompt nel parametro prompts dell'oggetto contesto. Per ogni prompt, viene inviata una richiesta POST all'API DALL-E con il prompt come didascalia e una risoluzione di 1024x1024. La risposta dell'API include un'intestazioneOperation-Location che contiene l'URL per lo stato dell'operazione di generazione dell'immagine.

Il codice attende quindi il numero di secondi specificato nell'intestazione Retry-after della risposta prima di inviare una richiesta GET a Operation-LocationURL per verificare lo stato dell'operazione di generazione dell'immagine. Questo processo viene ripetuto finché lo stato dell'operazione non diventa "Riuscito".

Una volta che l'operazione di generazione dell'immagine ha esito positivo, l'immagine risultante viene scaricata dal contentUrl specificato nella risposta e salvata in un file con un nome file che include un contatore per garantire che ogni immagine abbia un nome file univoco.

Nel complesso, questo codice definisce una classe che può essere utilizzata per generare immagini dal testo utilizzando l'API DALL-E. Utilizzando la classe SKContext per passare le informazioni di configurazione necessarie, questa classe può essere facilmente integrata in altre parti dell'applicazione.

Plug-in video

Per il Video Plugin, crea una nuova cartella denominata videoPlugin all'interno della cartella myPlugins.

Crea un nuovo file denominato videoPlugin.py

from moviepy.editor import *from semantic_kernel.skill_definition import ( sk_function )from semantic_kernel.orchestration.sk_context import SKContextclass VideoPlugin: _function( description="Crea immagini con i prompt forniti", name="create_video_file", input_description="Il contenuto da convertito in immagini", ) def create_video_file(self, contesto: SKContext): immagini = [] for i in range(1,11): immagini.append("Immagini/file" + str(i) + ".jpg") audio = "Audio/audio.mp4" output = "Video/video.mp4" self.create_video(immagini, audio, output) print("Video creato.....") def create_video(self,immagini, audio, output ): clips = [ImageClip(m).resize(height=1024).set_duration(3) for m in immagini] concat_clip = concatenate_videoclips(clips, metodo="compose") audio_clip = AudioFileClip(audio) final_clip = concat_clip.set_audio( audio_clip) final_clip.write_videofile(output, fps=20)

Spiegazione del codice:

Il codice sopra definisce una classe Python chiamata VideoPlugin che contiene un singolo metodo chiamato create_video_file. Questo metodo è decorato con ask_functiondecorator che definisce la funzione come un'abilità che può essere utilizzata nel kernel semantico.

Il metodo create_video_file accetta un singolo parametro di input chiamato contesto, che è un'istanza della classe SKContext. Questa classe è definita in un altro modulo e fornisce un modo per passare informazioni di contesto tra diverse parti dell'applicazione.

All'interno del metodo create_video_file, diverse variabili vengono inizializzate con i nomi dei file di immagini, audio e video di output. La variabile immagini è un elenco di nomi di file per le immagini che verranno utilizzate per creare il video. La variabile audio è il nome del file audio che verrà utilizzato come colonna sonora per il video. La variabile di output è il nome del file video di output.

Il metodo create_video viene quindi chiamato con le variabili immagini, audio e output come input. Questo metodo utilizza la libreria movie per creare un video dalle immagini e dall'audio in input.

Innanzitutto, viene creato un elenco di oggetti ImageClip dalle immagini di input. Ogni clip viene ridimensionata a un'altezza di 1024 pixel e impostata su una durata di 3 secondi.

Successivamente, la funzione concatenate_videoclips viene utilizzata per concatenare i clip in un singolo video clip. Il set_audiomethod viene quindi richiamato sulla clip concatenata con un oggetto AudioFileClip creato dal file audio di input come input.

Infine, viene richiamato il metodo write_videofile sulla clip risultante con il nome del file di output e una frequenza fotogrammi di 20 fotogrammi al secondo come input.

Se la creazione del video ha esito positivo, viene stampato un messaggio sulla console che indica che il video è stato creato.

Nel complesso, questo codice definisce una classe che può essere utilizzata per creare video da immagini e audio utilizzando la moviepylibrary. Utilizzando la classe SKContext per passare le informazioni di configurazione necessarie, questa classe può essere facilmente integrata in altre parti dell'applicazione.

Ora crea l'orchestrazione finale, crea un file denominato text_to_video.py e incolla il contenuto seguente.

import osimport semantic_kernel as skfrom semantic_kernel.connectors.ai.open_ai import AzureTextCompletionfrom myPlugins.audioPlugin.audioPlugin import AudioPluginfrom myPlugins.imagePlugin.imagePlugin import ImagePluginfrom myPlugins.videoPlugin.videoPlugin import VideoPluginfrom dotenv import load_dotenvimport time# Le funzioni semantiche vengono utilizzate per chiamare le competenze semantiche# 1. Riepiloga il testo di input# 2. Crea prompt immagine dal summarydef semanticFunctions(kernel, skills_directory, skill_name,input): funzioni = kernel.import_semantic_skill_from_directory(skills_directory, "myPlugins") summaryFunction =functions[skill_name] return summaryFunction(input) # Le funzioni native vengono utilizzate per chiamare le competenze native# 1. Crea audio dal riepilogo# 2. Crea immagini dai prompt delle immagini# 3. Crea video dalla definizione immagini nativeFunctions(kernel, context, plugin_class, skill_name, function_name): native_plugin = kernel .import_skill(plugin_class, skill_name) function = native_plugin[function_name] function.invoke(context=context) def main(): #Carica variabili d'ambiente dal file .env load_dotenv() # Crea un nuovo kernel kernel = sk.Kernel() contesto = kernel.create_new_context() # Configura il servizio AI utilizzato dalla distribuzione del kernel, api_key, endpoint = sk.azure_openai_settings_from_dot_env() # Aggiungi il servizio AI al kernel kernel.add_text_completion_service("dv", AzureTextCompletion(deployment, endpoint, api_key)) # Ottenere l'input dell'utente user_input = input("Inserisci il tuo contenuto:") # Generazione di riepilogo skills_directory = "." print("Generazione del riepilogo.............. ") start = time.time() result_sum = semanticFunctions(kernel, skills_directory,"summarizePlugin",user_input).result.split(' \n')[0] print("Tempo impiegato(sec): ", time.time() - inizio) # Generazione audio print("Creazione audio................ .") contesto["contenuto"] = somma_risultato contesto["speech_key"] = os.getenv("SPEECH_KEY") contesto["speech_region"] = os.getenv("SPEECH_REGION") start = time.time() nativeFunctions( kernel, context, AudioPlugin(),"audio_plugin","create_audio_file") print("Tempo impiegato(sec): ", time.time() - start) # Generazione di prompt immagine print("Creazione di prompt Dall-e... ..............") start = time.time() image_prompts = semanticFunctions(kernel,skills_directory,"promptPlugin",result_sum).result.split('\n\n')[ 0].split("<")[0].split('\n') print("Tempo impiegato(sec): ", time.time() - start) # Generazione di immagini print("Creazione di immagini... ..............") contesto["prompts"] = image_prompts contesto["api_base"] = os.getenv("DALLE_API_BASE") contesto["api_key"] = os.getenv( "DALLE_API_KEY") context["api_version"] = os.getenv("DALLE_API_VERSION") start = time.time() nativeFunctions(kernel, context, ImagePlugin(),"image_plugin","create_image_files") print("Tempo impiegato( secs): ", time.time() - start) # Generazione del video print("Creazione del video...............") start = time.time() nativeFunctions(kernel , contesto, VideoPlugin(),"video_plugin","crea_video_file") print("Tempo impiegato(secondi): ", time.time() - start) if __name__ == "__main__": start = time.time() main () print("Tempo impiegato complessivo(minuti): ", (time.time() - inizio)/60)

Spiegazione del codice:

Il codice sopra è uno script Python che genera un video dal testo di input di un utente utilizzando diversi plugin. Lo script utilizza il kernel semantico per richiamare competenze semantiche e native che eseguono varie attività come il riepilogo del testo di input, la generazione di audio, la creazione di prompt di immagini e la creazione di un video dalle immagini.

Lo script inizia importando diversi moduli, tra cui Thesemantic_kernelmodule, che fornisce la funzionalità per il kernel semantico e diversi plugin personalizzati utilizzati per generare audio, immagini e video. Il modulo dotenv viene importato anche per caricare le variabili di ambiente da un file.env.

Successivamente, viene creata una nuova istanza del kernel semantico e un nuovo contesto all'interno del kernel. Lo script configura quindi un servizio AI che deve essere utilizzato dal kernel utilizzando la funzioneazure_openai_settings_from_dot_env, che legge le impostazioni necessarie dal file.env.

All'utente viene quindi richiesto di inserire il testo di input, che viene utilizzato per generare un riepilogo del testo utilizzando un'abilità semantica chiamatasummarizePlugin. La funzione Funzionimantiche viene utilizzata per chiamare questa abilità e restituire il riepilogo.

Lo script genera quindi l'audio dal riepilogo utilizzando una competenza nativa denominata audio_plugin. La funzione ThenativeFunctions viene utilizzata per chiamare questa abilità e passare le informazioni di contesto necessarie, incluso il testo di riepilogo, la chiave API e la regione per il servizio vocale.

Successivamente, lo script genera prompt immagine dal riepilogo utilizzando un'altra abilità semantica chiamata promptPlugin. La funzione Funzionimantiche viene utilizzata per chiamare questa abilità e restituire i prompt dell'immagine.

Lo script genera quindi immagini dai prompt delle immagini utilizzando una competenza nativa chiamata image_plugin. La funzione ThenativeFunctions viene utilizzata per chiamare questa competenza e passare le informazioni di contesto necessarie, inclusi i prompt dell'immagine e la base, la chiave e la versione dell'API per l'API DALL-E.

Infine, lo script genera un video dalle immagini utilizzando un'altra abilità nativa chiamata video_plugin. La funzione ThenativeFunctions viene utilizzata per chiamare questa abilità e passare le informazioni di contesto necessarie, inclusi i nomi dei file delle immagini e dell'audio e il nome del file di output per il video.

Lo script include anche diverse istruzioni print che forniscono informazioni sull'avanzamento dello script, incluso il tempo impiegato per completare ogni passaggio. Alla fine viene stampato anche il tempo totale impiegato per completare lo script.

Nel complesso, questo script dimostra come il kernel semantico possa essere utilizzato per richiamare competenze semantiche e native per eseguire attività complesse come la generazione di un video dal testo. Utilizzando plug-in progettati specificamente per ciascuna attività, lo script è in grado di generare audio, immagini e video di alta qualità dal testo di input.

In questa puntata della nostra esplorazione della convergenza tra Azure e OpenAI, abbiamo approfondito il mondo delle possibilità con Semantic Kernel. Dopo esserci avventurati in precedenza nella trasformazione del testo in video utilizzando le formidabili funzionalità di intelligenza artificiale di Azure, ora abbiamo intrapreso un viaggio più intricato orchestrando il flusso della nostra applicazione con l'abilità di Semantic Kernel.

Il kernel semantico, uno strumento potente, ci consente di comprendere e manipolare i significati testuali con un tocco più sottile. Attraverso la sua implementazione, siamo in grado di creare flussi di lavoro più complessi e ottenere risultati più ricchi dal processo di conversione del testo in video.

In questo segmento, ci siamo concentrati sul miglioramento che Semantic Kernel apporta alla nostra applicazione, aprendo la strada a un flusso di lavoro più fluido ed efficiente. Abbiamo esplorato le sue funzionalità in modo approfondito, svelato i suoi vantaggi e mostrato come abbia il potenziale per rivoluzionare la trasformazione del testo in accattivanti contenuti video.

Un cambiamento fondamentale nel nostro approccio questa volta è stata l'omissione della fase di riconoscimento dell'entità dal nostro blog precedente. Questa decisione, attentamente ponderata, ci ha permesso di semplificare il nostro processo e incanalare i nostri sforzi verso ciò che conta davvero: creare contenuti video impeccabili dal testo.

Preparati per un viaggio emozionante nel regno di Semantic Kernel e Azure. Man mano che procediamo, ricorda che puoi sempre fare riferimento al nostro post precedente per ulteriori approfondimenti.

Per coloro che non hanno familiarità con le tecnologie coinvolte, non preoccupatevi. Ti abbiamo coperto con i prerequisiti delineati nelle sezioni successive, fornendoti le basi necessarie per intraprendere questo viaggio.

Mentre andiamo avanti, ricorda che la sinergia di Azure e OpenAI, combinata con le meraviglie modulari di Semantic Kernel, ha il potenziale per rimodellare il modo in cui percepiamo e sfruttiamo la potenza dell'intelligenza artificiale. Quindi, allacciatevi le cinture e unitevi a noi mentre ci immergiamo più a fondo in questo entusiasmante regno di innovazione e trasformazione.