Insert all files

app.py

@@ -1,17 +1,89 @@
+# Install libraries
+
 import streamlit as st
-from diffusers import DDPMScheduler, UNet2DModel
 from PIL import Image
-import torch
-import numpy as np
+import streamlit as st
+from transformers import pipeline
+import pandas as pd
+import plotly.express as px
+import matplotlib.pyplot as plt
+from pathlib import Path
+import base64
+from st_pages import Page, add_page_title, show_pages
+from streamlit_extras.badges import badge
+
+
+# Config
+# Initial page config
+
+st.set_page_config(
+     page_title='RetrAIced',
+     page_icon=':🧠:',
+     layout="wide",
+     initial_sidebar_state="expanded",
+)
+
+def local_css(file_name):
+    with open(file_name) as f:
+        st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+
+local_css("style.css")
+
+
+def img_to_bytes(img_path):
+    img_bytes = Path(img_path).read_bytes()
+    encoded = base64.b64encode(img_bytes).decode()
+    return encoded
+
+
+show_pages(
+        [
+            Page("app.py", "Home", "🏠"),
+            Page("pages/Question Answering.py", "Question Answering", ":grey_question:"),
+            Page("pages/Speech Recognition.py", "Speech Recognition", ":speaking_head_in_silhouette:"),
+            Page("pages/Summarization.py", "Summarization",":bookmark_tabs:"),
+            Page("pages/Text to Image.py", "Text to Image",":lower_left_paintbrush:"),
+            Page("pages/Text Classification.py",'Text Classification',":book:"),
+            Page("pages/Image to text.py","Image to Text",":camera:"),
+            Page("pages/Text Generation.py", "Text Generation", ":printer:"),
+        ]
+    )
+
+#Add streamlit logo
+
+st.image("logo retraced 2.png")
+st.header("Intro")
+st.write("##")
+st.markdown(
+    """
+    Welcome to **RetrAIced**, a user-friendly app that unifies a diverse array of AI models, offering a seamless platform for exploration and interaction. From natural language processing to image recognition,
+    the app provides a comprehensive experience, showcasing real-time demonstrations of predictive analytics and the fusion of various AI technologies. \n
+
+    Language models (LLMs), especially those from Hugging Face, have transformed natural language understanding and generation, becoming indispensable in today's data-driven world. 
+    RetrAIced exemplifies the collaborative potential of AI by breaking down barriers between different models, making their collective power accessible to users of all backgrounds. 
+    The app invites developers, data enthusiasts, and the curious to explore and experiment with models for tasks like Question Answering, Speech Recognition, Summarization, Text 
+    Classification, and Text Generation. This unified experience paves the way for a connected and intelligent digital world, where projects can become more versatile, efficient, and engaging.\n
+
+    Join the creator on an exciting journey into the world of language models through RetrAIced, unlocking a universe of possibilities and transforming complexities into a unified and intuitive AI experience.
+
+    """
+    , unsafe_allow_html=True)
+
+
+st.write("##")
+st.write("##")
+
+#Create 2 columns to add github repo and huggging face repo
+left_col, right_col = st.columns(2)
+
+with left_col:
+    st.info('**Hugging Face: [@JavierGon12](https://huggingface.co/JavierGon12)**', icon="💡")
 
-import torch
-from diffusers import StableDiffusionPipeline
+with right_col:
 
-pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16)
-pipe = pipe.to("cuda")
+    badge(type='github',name='JaviGon12')
+    #st.info('**GitHub: [@JaviGon12](https://github.com/JaviGon12)**', icon="💻")
 
-prompt = st.text_input('Insert here your prompt')
 
-image = pipe(prompt).images[0]
 
 

pages/Image to text.py

@@ -0,0 +1,19 @@
+from transformers import Pix2StructProcessor, Pix2StructForConditionalGeneration
+import requests
+from PIL import Image
+import streamlit as st
+
+processor = Pix2StructProcessor.from_pretrained('google/deplot')
+model = Pix2StructForConditionalGeneration.from_pretrained('google/deplot')
+
+document = st.file_uploader(label="Upload the document you want to explore",type=["png",'jpg', "jpeg","pdf"])
+
+if document == None:
+    st.write("Please upload the document in the box above")
+else:
+    image = Image.open(document)
+    st.image(image,"Document uploaded")
+
+    inputs = processor(images=image, text="Generate underlying data table of the figure below:", return_tensors="pt")
+    predictions = model.generate(**inputs, max_new_tokens=512)
+    st.write(processor.decode(predictions[0], skip_special_tokens=True))

pages/Question Answering.py

@@ -0,0 +1,85 @@
+import re
+import streamlit as st
+from transformers import DonutProcessor, VisionEncoderDecoderModel
+from datasets import load_dataset
+import torch
+import os
+from PIL import Image
+import PyPDF2
+from pypdf.errors import PdfReadError
+from pypdf import PdfReader
+import pypdfium2 as pdfium
+processor = DonutProcessor.from_pretrained("naver-clova-ix/donut-base-finetuned-docvqa")
+model = VisionEncoderDecoderModel.from_pretrained("naver-clova-ix/donut-base-finetuned-docvqa")
+
+device ="cpu"
+model.to(device)
+
+#create uploader
+document = st.file_uploader(label="Upload the document you want to explore",type=["png",'jpg', "jpeg","pdf"])
+
+question = st.text_input(str("Insert here you question?"))
+
+if document == None:
+    st.write("Please upload the document in the box above")
+else:
+    try:
+        PdfReader(document)
+        pdf = pdfium.PdfDocument(document)
+        page = pdf.get_page(0)
+        pil_image = page.render(scale = 300/72).to_pil()
+        #st.image(pil_image, caption="Document uploaded", use_column_width=True)
+        task_prompt = "<s_docvqa><s_question>{user_input}</s_question><s_answer>"
+        #question = "What's the total amount?"
+        prompt = task_prompt.replace("{user_input}", question)
+        decoder_input_ids = processor.tokenizer(prompt, add_special_tokens=False, return_tensors="pt").input_ids
+        pixel_values = processor(pil_image, return_tensors="pt").pixel_values     
+        outputs = model.generate(
+                pixel_values.to(device),
+            decoder_input_ids=decoder_input_ids.to(device),
+            max_length=model.decoder.config.max_position_embeddings,
+            pad_token_id=processor.tokenizer.pad_token_id,
+            eos_token_id=processor.tokenizer.eos_token_id,
+            use_cache=True,
+            bad_words_ids=[[processor.tokenizer.unk_token_id]],
+            return_dict_in_generate=True,
+        )
+        sequence = processor.batch_decode(outputs.sequences)[0]
+        sequence = sequence.replace(processor.tokenizer.eos_token, "").replace(processor.tokenizer.pad_token, "")
+        sequence = re.sub(r"<.*?>", "", sequence, count=1).strip()  # remove first task start token
+        st.image(pil_image,"Document uploaded")
+        st.write(processor.token2json(sequence))
+        print(processor.token2json(sequence))
+
+
+    except PdfReadError:
+        #image = Image.open(document)
+        #st.image(document, caption="Document uploaded", use_column_width=False)
+        # prepare decoder inputs
+        document = Image.open(document)
+
+        task_prompt = "<s_docvqa><s_question>{user_input}</s_question><s_answer>"
+        #question = "What's the total amount?"
+        prompt = task_prompt.replace("{user_input}", question)
+        decoder_input_ids = processor.tokenizer(prompt, add_special_tokens=False, return_tensors="pt").input_ids
+        pixel_values = processor(document, return_tensors="pt").pixel_values
+
+        outputs = model.generate(
+            pixel_values.to(device),
+            decoder_input_ids=decoder_input_ids.to(device),
+            max_length=model.decoder.config.max_position_embeddings,
+            pad_token_id=processor.tokenizer.pad_token_id,
+            eos_token_id=processor.tokenizer.eos_token_id,
+            use_cache=True,
+            bad_words_ids=[[processor.tokenizer.unk_token_id]],
+            return_dict_in_generate=True,
+        )
+        sequence = processor.batch_decode(outputs.sequences)[0]
+        sequence = sequence.replace(processor.tokenizer.eos_token, "").replace(processor.tokenizer.pad_token, "")
+        sequence = re.sub(r"<.*?>", "", sequence, count=1).strip()  # remove first task start token
+        st.image(document,"Document uploaded")
+        st.write(processor.token2json(sequence))
+
+
+
+

pages/Speech Recognition.py

@@ -0,0 +1,180 @@
+from transformers import BartForConditionalGeneration, BartTokenizer
+import streamlit as st
+import torch
+from transformers import AutoProcessor, WhisperForConditionalGeneration
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+import torchaudio
+from transformers import pipeline
+from streamlit_mic_recorder import mic_recorder,speech_to_text
+import numpy as np
+
+
+option = st.selectbox("How do you want to import the audio file?",("Microphone","Upload file"))
+if option == "Microphone":
+# Load your own audio file
+    st.write("Record your voice, and play the recorded audio:")
+    audio = mic_recorder(start_prompt="Press the botton to start recording ⏺️",stop_prompt="Press the botton to stop to stop the recording⏹️",key='recorder')
+    
+    if audio == None:
+        st.write("Please start the recording in the box above")
+    else:       
+        st.audio(audio["bytes"])
+
+elif option == "Upload file":
+    audio = st.file_uploader(label="Upload your audio file here",type=["wav",'mp3'])
+    if audio:
+        st.audio(audio)
+
+option_language = st.selectbox(
+    'Select the language of your audio',
+    ('English', 'Spanish', 'German','French','Chinese'))
+
+
+if audio == None:
+    st.write("Please upload the audio in the box above")
+
+
+else:
+    if option_language == "English":
+        def transcribe_audio(audio_file):
+            # Load the audio file
+            waveform, sample_rate = torchaudio.load(audio_file)
+
+            # Ensure mono-channel audio
+            if waveform.shape[0] > 1:
+                waveform = torch.mean(waveform, dim=0, keepdim=True)
+
+            # Convert to a 16kHz sample rate if not already
+            if sample_rate != 16000:
+                waveform = torchaudio.transforms.Resample(sample_rate, 16000)(waveform)
+            
+            # Convert to a list of integers
+            audio_input = waveform.squeeze().numpy().astype(int).tolist()
+
+            # Use Hugging Face's ASR pipeline
+            asr_pipeline = pipeline("automatic-speech-recognition", model="openai/whisper-large-v2")
+            
+            # Transcribe the audio
+            transcript = asr_pipeline(waveform.numpy()[0])
+
+            return transcript
+
+        transcription = transcribe_audio(audio)
+        st.write("Here is your transcription:")
+        st.write(transcription)
+
+    elif option_language == 'Spanish':
+
+        def transcribe_audio(audio_file):
+            
+            # Load the audio file
+            waveform, sample_rate = torchaudio.load(audio_file)
+
+            # Ensure mono-channel audio
+            if waveform.shape[0] > 1:
+                waveform = torch.mean(waveform, dim=0, keepdim=True)
+
+            # Convert to a 16kHz sample rate if not already
+            if sample_rate != 16000:
+                waveform = torchaudio.transforms.Resample(sample_rate, 16000)(waveform)
+            
+            # Convert to a list of integers
+            audio_input = waveform.squeeze().numpy().astype(int).tolist()
+
+            # Use Hugging Face's ASR pipeline
+            asr_pipeline = pipeline("automatic-speech-recognition", model="Sandiago21/whisper-large-v2-spanish")
+            
+            # Transcribe the audio
+            transcript = asr_pipeline(waveform.numpy()[0])
+
+            return transcript
+        
+        transcription = transcribe_audio(audio)
+        st.write("Aqui tienes tu transcripcion:")
+        st.write(transcription)
+    elif option_language == 'German':
+        def transcribe_audio(audio_file):
+            
+            # Load the audio file
+            waveform, sample_rate = torchaudio.load(audio_file)
+
+            # Ensure mono-channel audio
+            if waveform.shape[0] > 1:
+                waveform = torch.mean(waveform, dim=0, keepdim=True)
+
+            # Convert to a 16kHz sample rate if not already
+            if sample_rate != 16000:
+                waveform = torchaudio.transforms.Resample(sample_rate, 16000)(waveform)
+            
+            # Convert to a list of integers
+            audio_input = waveform.squeeze().numpy().astype(int).tolist()
+
+            # Use Hugging Face's ASR pipeline
+            asr_pipeline = pipeline("automatic-speech-recognition", model="primeline/whisper-large-v3-german")
+            
+            # Transcribe the audio
+            transcript = asr_pipeline(waveform.numpy()[0])
+
+            return transcript
+        
+        transcription = transcribe_audio(audio)
+        st.write("Hier ist Ihre Transkription:")
+        st.write(transcription)
+    elif option_language == "French":
+        def transcribe_audio(audio_file):
+            
+            # Load the audio file
+            waveform, sample_rate = torchaudio.load(audio_file)
+
+            # Ensure mono-channel audio
+            if waveform.shape[0] > 1:
+                waveform = torch.mean(waveform, dim=0, keepdim=True)
+
+            # Convert to a 16kHz sample rate if not already
+            if sample_rate != 16000:
+                waveform = torchaudio.transforms.Resample(sample_rate, 16000)(waveform)
+            
+            # Convert to a list of integers
+            audio_input = waveform.squeeze().numpy().astype(int).tolist()
+
+            # Use Hugging Face's ASR pipeline
+            asr_pipeline = pipeline("automatic-speech-recognition", model="bofenghuang/whisper-large-v2-french")
+            
+            # Transcribe the audio
+            transcript = asr_pipeline(waveform.numpy()[0])
+
+            return transcript
+        
+        transcription = transcribe_audio(audio)
+        st.write("Ici, vous avez votre transcription")
+        st.write(transcription)
+
+    elif option_language == "Chinese":
+        def transcribe_audio(audio_file):
+            
+            # Load the audio file
+            waveform, sample_rate = torchaudio.load(audio_file)
+
+            # Ensure mono-channel audio
+            if waveform.shape[0] > 1:
+                waveform = torch.mean(waveform, dim=0, keepdim=True)
+
+            # Convert to a 16kHz sample rate if not already
+            if sample_rate != 16000:
+                waveform = torchaudio.transforms.Resample(sample_rate, 16000)(waveform)
+            
+            # Convert to a list of integers
+            audio_input = waveform.squeeze().numpy().astype(int).tolist()
+
+            # Use Hugging Face's ASR pipeline
+            asr_pipeline = pipeline("automatic-speech-recognition", model="yi-ching/whisper-tiny-chinese-test")
+            
+            # Transcribe the audio
+            transcript = asr_pipeline(waveform.numpy()[0])
+
+            return transcript
+        
+        transcription = transcribe_audio(audio)
+        st.write("这是您的转录。")
+        st.write(transcription)
+

pages/Summarization.py

@@ -0,0 +1,109 @@
+from transformers import BartForConditionalGeneration, BartTokenizer
+import streamlit as st
+import torch
+from transformers import AutoProcessor, WhisperForConditionalGeneration
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+import torchaudio
+from transformers import pipeline
+
+# Load your own audio file
+
+audio = st.file_uploader(label="Upload your audio file here",type=["wav",'mp3'])
+
+option_language = st.selectbox(
+    'Select the language of your audio',
+    ('English', 'Spanish', 'German','French','Chinese'))
+
+if audio == None:
+    st.write("Please upload the audio in the box above")
+
+
+
+else:
+    if option_language == "English":
+        def transcribe_audio(audio_file):
+            # Load the audio file
+            waveform, sample_rate = torchaudio.load(audio_file)
+
+            # Ensure mono-channel audio
+            if waveform.shape[0] > 1:
+                waveform = torch.mean(waveform, dim=0, keepdim=True)
+
+            # Convert to a 16kHz sample rate if not already
+            if sample_rate != 16000:
+                waveform = torchaudio.transforms.Resample(sample_rate, 16000)(waveform)
+            
+            # Convert to a list of integers
+            audio_input = waveform.squeeze().numpy().astype(int).tolist()
+
+            # Use Hugging Face's ASR pipeline
+            asr_pipeline = pipeline("automatic-speech-recognition", model="facebook/wav2vec2-base-960h")
+            
+            # Transcribe the audio
+            transcript = asr_pipeline(waveform.numpy()[0])
+
+            return transcript
+
+        transcription = transcribe_audio(audio)
+        print("Transcription",transcription)
+
+        ## Inititate Summary Model
+        tokenizer_summary = BartTokenizer.from_pretrained("facebook/bart-large-cnn")
+        model_summary = BartForConditionalGeneration.from_pretrained("facebook/bart-large-cnn")
+
+
+        def summarize_text(text, model, tokenizer, max_length=100):
+            input_ids = tokenizer.encode(text, return_tensors="pt")
+            summary_ids = model.generate(input_ids, max_length=max_length, num_beams=4, early_stopping=True)
+            return tokenizer.decode(summary_ids[0], skip_special_tokens=True)
+
+
+        summary = summarize_text(transcription['text'], model_summary, tokenizer_summary)
+        st.write("Here is your summary!")
+        st.write(summary)
+
+
+    elif option_language == 'Spanish':
+
+        def transcribe_audio(audio_file):
+            
+            # Load the audio file
+            waveform, sample_rate = torchaudio.load(audio_file)
+
+            # Ensure mono-channel audio
+            if waveform.shape[0] > 1:
+                waveform = torch.mean(waveform, dim=0, keepdim=True)
+
+            # Convert to a 16kHz sample rate if not already
+            if sample_rate != 16000:
+                waveform = torchaudio.transforms.Resample(sample_rate, 16000)(waveform)
+            
+            # Convert to a list of integers
+            audio_input = waveform.squeeze().numpy().astype(int).tolist()
+
+            # Use Hugging Face's ASR pipeline
+            asr_pipeline = pipeline("automatic-speech-recognition", model="Sandiago21/whisper-large-v2-spanish")
+            
+            # Transcribe the audio
+            transcript = asr_pipeline(waveform.numpy()[0])
+
+            return transcript
+
+        transcription = transcribe_audio(audio)
+        print("Aqui tienes tu transcripción:",transcription)
+
+        ## Inititate Summary Model
+        
+        tokenizer_summary = AutoTokenizer.from_pretrained("facebook/mbart-large-50", src_lang="es_XX")
+        model_summary = AutoModelForSeq2SeqLM.from_pretrained("facebook/mbart-large-50")
+
+
+        def summarize_text(text, model, tokenizer, max_length=100):
+            input_ids = tokenizer.encode(text, return_tensors="pt")
+            summary_ids = model.generate(input_ids, max_length=max_length, num_beams=4, early_stopping=True)
+            return tokenizer.decode(summary_ids[0], skip_special_tokens=True)
+
+
+        summary = summarize_text(transcription['text'], model_summary, tokenizer_summary)
+        st.write("Aqui tienes tu resumen!")
+        st.write(summary)

pages/Text Classification.py

@@ -0,0 +1,139 @@
+import re
+from transformers import DonutProcessor, VisionEncoderDecoderModel
+from datasets import load_dataset
+import torch
+import streamlit as st
+from PIL import Image
+import PyPDF2
+from pypdf.errors import PdfReadError
+from pypdf import PdfReader
+import pypdfium2 as pdfium
+
+document = st.file_uploader(label="Upload the document you want to explore",type=["png",'jpg', "jpeg","pdf"])
+
+
+model_option = st.selectbox("Select the output of the model:",["Classification","Extract Info"])
+if model_option == "Classification":
+    processor = DonutProcessor.from_pretrained("naver-clova-ix/donut-base-finetuned-rvlcdip")
+    model = VisionEncoderDecoderModel.from_pretrained("naver-clova-ix/donut-base-finetuned-rvlcdip")
+
+    device = "cpu"
+    model.to(device)
+    # load document image
+    if document == None:
+        st.write("Please upload the document in the box above")
+    else:
+        try:
+            PdfReader(document)
+            pdf = pdfium.PdfDocument(document)
+            page = pdf.get_page(0)
+            pil_image = page.render(scale = 300/72).to_pil()
+
+            task_prompt = "<s_rvlcdip>"
+            decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors="pt").input_ids
+
+            pixel_values = processor(pil_image, return_tensors="pt").pixel_values
+
+            outputs = model.generate(
+                pixel_values.to(device),
+                decoder_input_ids=decoder_input_ids.to(device),
+                max_length=model.decoder.config.max_position_embeddings,
+                pad_token_id=processor.tokenizer.pad_token_id,
+                eos_token_id=processor.tokenizer.eos_token_id,
+                use_cache=True,
+                bad_words_ids=[[processor.tokenizer.unk_token_id]],
+                return_dict_in_generate=True,
+            )
+
+            sequence = processor.batch_decode(outputs.sequences)[0]
+            sequence = sequence.replace(processor.tokenizer.eos_token, "").replace(processor.tokenizer.pad_token, "")
+            sequence = re.sub(r"<.*?>", "", sequence, count=1).strip()  # remove first task start token
+            st.image(pil_image,"Document uploaded")
+            st.write(processor.token2json(sequence))
+
+        except PdfReadError:
+            document = Image.open(document)
+            task_prompt = "<s_rvlcdip>"
+            decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors="pt").input_ids
+
+            pixel_values = processor(document, return_tensors="pt").pixel_values
+
+            outputs = model.generate(
+                pixel_values.to(device),
+                decoder_input_ids=decoder_input_ids.to(device),
+                max_length=model.decoder.config.max_position_embeddings,
+                pad_token_id=processor.tokenizer.pad_token_id,
+                eos_token_id=processor.tokenizer.eos_token_id,
+                use_cache=True,
+                bad_words_ids=[[processor.tokenizer.unk_token_id]],
+                return_dict_in_generate=True,
+            )
+
+            sequence = processor.batch_decode(outputs.sequences)[0]
+            sequence = sequence.replace(processor.tokenizer.eos_token, "").replace(processor.tokenizer.pad_token, "")
+            sequence = re.sub(r"<.*?>", "", sequence, count=1).strip()  # remove first task start token
+            st.image(document,"Document uploaded")
+            st.write(processor.token2json(sequence))
+
+
+elif model_option == "Extract Info":
+    processor = DonutProcessor.from_pretrained("naver-clova-ix/donut-base-finetuned-cord-v2")
+    model = VisionEncoderDecoderModel.from_pretrained("naver-clova-ix/donut-base-finetuned-cord-v2")
+
+    device = "cpu"
+    model.to(device)
+    # load document image
+    if document == None:
+        st.write("Please upload the document in the box above")
+    else:
+        try:
+            PdfReader(document)
+            pdf = pdfium.PdfDocument(document)
+            page = pdf.get_page(0)
+            pil_image = page.render(scale = 300/72).to_pil()
+
+            task_prompt = "<s_cord-v2>"
+            decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors="pt").input_ids
+
+            pixel_values = processor(pil_image, return_tensors="pt").pixel_values
+
+            outputs = model.generate(
+                pixel_values.to(device),
+                decoder_input_ids=decoder_input_ids.to(device),
+                max_length=model.decoder.config.max_position_embeddings,
+                pad_token_id=processor.tokenizer.pad_token_id,
+                eos_token_id=processor.tokenizer.eos_token_id,
+                use_cache=True,
+                bad_words_ids=[[processor.tokenizer.unk_token_id]],
+                return_dict_in_generate=True,
+            )
+
+            sequence = processor.batch_decode(outputs.sequences)[0]
+            sequence = sequence.replace(processor.tokenizer.eos_token, "").replace(processor.tokenizer.pad_token, "")
+            sequence = re.sub(r"<.*?>", "", sequence, count=1).strip()  # remove first task start token
+            st.image(pil_image,"Document uploaded")
+            st.write(processor.token2json(sequence))
+
+        except PdfReadError:
+            document = Image.open(document)
+            task_prompt = "<s_cord-v2>"
+            decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors="pt").input_ids
+
+            pixel_values = processor(document, return_tensors="pt").pixel_values
+
+            outputs = model.generate(
+                pixel_values.to(device),
+                decoder_input_ids=decoder_input_ids.to(device),
+                max_length=model.decoder.config.max_position_embeddings,
+                pad_token_id=processor.tokenizer.pad_token_id,
+                eos_token_id=processor.tokenizer.eos_token_id,
+                use_cache=True,
+                bad_words_ids=[[processor.tokenizer.unk_token_id]],
+                return_dict_in_generate=True,
+            )
+
+            sequence = processor.batch_decode(outputs.sequences)[0]
+            sequence = sequence.replace(processor.tokenizer.eos_token, "").replace(processor.tokenizer.pad_token, "")
+            sequence = re.sub(r"<.*?>", "", sequence, count=1).strip()  # remove first task start token
+            st.image(document,"Document uploaded")
+            st.write(processor.token2json(sequence))

pages/Text Generation.py

@@ -0,0 +1,25 @@
+import streamlit as st
+from streamlit_mic_recorder import mic_recorder,speech_to_text
+
+state=st.session_state
+
+if 'text_received' not in state:
+    state.text_received=[]
+
+c1,c2=st.columns(2)
+with c1:
+    st.write("Convert speech to text:")
+with c2:
+    text=speech_to_text(language='en',use_container_width=True,just_once=True,key='STT')
+
+if text:       
+    state.text_received.append(text)
+
+for text in state.text_received:
+    st.text(text)
+
+st.write("Record your voice, and play the recorded audio:")
+audio=mic_recorder(start_prompt="⏺️",stop_prompt="⏹️",key='recorder')
+
+if audio:       
+    st.audio(audio['bytes'])

pages/Text to Image.py

@@ -0,0 +1,19 @@
+import torch
+from diffusers import LCMScheduler, AutoPipelineForText2Image
+import streamlit as st
+
+model_id = "stabilityai/stable-diffusion-xl-base-1.0"
+adapter_id = "latent-consistency/lcm-lora-sdxl"
+
+pipe = AutoPipelineForText2Image.from_pretrained(model_id, torch_dtype=torch.float32, variant="fp16")
+pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
+#pipe.to("cuda")
+
+# load and fuse lcm lora
+pipe.load_lora_weights(adapter_id)
+pipe.fuse_lora()
+prompt = st.text_input(str("Insert here you prompt?"))
+
+# disable guidance_scale by passing 0
+image = pipe(prompt=prompt, num_inference_steps=4, guidance_scale=0).images[0]
+st.image(image,"Image generated by your prompt {promt}")

style.css

@@ -0,0 +1,54 @@
+
+/* styles.css */
+
+.title {
+  color: #ffffff;
+  font-size: 34px;
+  font-weight: bold;
+  font-family:  monospace;
+}
+
+.custom-text {
+  color: #ffffff;
+  font-size: 20px;
+  font-weight: bold;
+  font-family:  monospace;
+
+}
+
+.custom-background {
+  background-color: rgb(110, 159, 238);
+  padding: 12px;
+  font-size: 16px;
+  font-family:  monospace;
+
+}
+
+/* Style inputs with type="text", type="email"and textareas */
+input[type=text], input[type=email], textarea {
+  width: 100%; /* Full width */
+  padding: 12px; /* Some padding */ 
+  border: 1px solid #ccc; /* Gray border */
+  border-radius: 4px; /* Rounded borders */
+  box-sizing: border-box; /* Make sure that padding and width stays in place */
+  margin-top: 6px; /* Add a top margin */
+  margin-bottom: 16px; /* Bottom margin */
+  resize: vertical /* Allow the user to vertically resize the textarea (not horizontally) */
+}
+
+/* Style the submit button with a specific background color etc */
+button[type=submit] {
+  background-color: #04AA6D;
+  color: white;
+  padding: 12px 20px;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+}
+
+/* When moving the mouse over the submit button, add a darker green color */
+button[type=submit]:hover {
+  background-color: #45a049;
+}
+
+