Beskrivning

Artificiell intelligens har många användningsfall, och några av de bästa finns inom hälsobranschen. Det kan verkligen hjälpa människor att upprätthålla ett hälsosammare liv. Med den ökande boomen in generativ AI, vissa ansökningar görs nuförtiden med mindre komplexitet. En mycket användbar applikation som kan byggas är Calorie Advisor-appen. I den här artikeln kommer vi bara att titta på detta, inspirerat av att ta hand om vår hälsa. Vi kommer att bygga en enkel Calorie Advisor-app där vi kan mata in bilder på maten, och appen hjälper oss att beräkna kalorierna för varje föremål som finns i maten. Detta projekt är en del av NutriGen, med fokus på hälsa genom AI.

Lärande mål

• Appen vi kommer att skapa i den här artikeln kommer att baseras på grundläggande promptteknik och bildbehandlingstekniker.
• Vi kommer att använda Google Gemini Pro Vision API för vårt användningsfall.
• Sedan kommer vi att skapa kodens struktur, där vi kommer att utföra bildbehandling och promptteknik. Slutligen kommer vi att arbeta med användargränssnittet med Streamlit.
• Efter det kommer vi att distribuera vår app till Kramande ansikte Plattform gratis.
• Vi kommer också att se några av problemen vi kommer att möta i produktionen där Tvillingarna misslyckas med att avbilda en matvara och ger fel kalorivärde för den maten. Vi kommer också att diskutera olika lösningar på detta problem.

Förutsättningar

Låt oss börja med att implementera vårt projekt, men innan dess, se till att du har en grundläggande förståelse för generativ AI och LLM. Det är okej om du vet väldigt lite eftersom vi i den här artikeln kommer att implementera saker från grunden.

För Essential Python Prompt Engineering krävs en grundläggande förståelse för Generativ AI och förtrogenhet med Google Gemini. Dessutom grundläggande kunskaper om Strömbelyst, Githuboch Kramande ansikte bibliotek är nödvändigt. Bekantskap med bibliotek som PIL för bildförbehandling är också fördelaktigt.

Denna artikel publicerades som en del av Data Science Blogathon.

Projektrörledning

I den här artikeln kommer vi att arbeta med att bygga en AI-assistent som hjälper nutritionister och individer att fatta välgrundade beslut om sina matval och upprätthålla en hälsosam livsstil.

Flödet kommer att vara så här: ingångsbild -> bildbehandling -> promptteknik -> slutfunktionsanrop för att få utdata från matens ingångsbild. Detta är en kort översikt över hur vi kommer att förhålla oss till denna problemformulering.

Översikt över Gemini Pro Vision

GeminiPro är en multimodal LLM byggd av Google. Den tränades för att vara multimodal från grunden. Det kan fungera bra på olika uppgifter, inklusive bildtextning, klassificering, sammanfattning, frågesvar, etc. En av de fascinerande fakta om den är att den använder vår berömda Transformer Decoder Architecture. Den tränades på flera typer av data, vilket minskade komplexiteten i att lösa multimodala indata och gav kvalitetsutdata.

Steg 1: Skapa den virtuella miljön

Att skapa en virtuell miljö är en bra praxis för att isolera vårt projekt och dess beroenden så att de inte sammanfaller med andra, och vi kan alltid ha olika versioner av bibliotek vi behöver i olika virtuella miljöer. Så vi kommer att skapa en virtuell miljö för projektet nu. För att göra detta, följ de nämnda stegen nedan:

• Skapa en tom mapp på skrivbordet för projektet.
• Öppna den här mappen i VS Code.
• Öppna terminalen.

Skriv följande kommando:

pip install virtualenv
python -m venv genai_project

Du kan använda följande kommando om du får sa et exekveringspolicyfel:

Set-ExecutionPolicy RemoteSigned -Scope Process

Nu måste vi aktivera vår virtuella miljö, för det använd följande kommando:

.genai_projectScriptsactivate

Vi har framgångsrikt skapat vår virtuella miljö.

Steg Skapa virtuell miljö i Google Colab

Vi kan också skapa vår virtuella miljö i Google Colab; här är steg-för-steg-proceduren för att göra det:

• Skapa en ny Colab-anteckningsbok
• Använd kommandona nedan steg för steg

!which python
!python --version
#to check if python is installed or not

%env PYTHONPATH=
# setting python path environment variable in empty value ensuring that python
# won't search for modules and packages in additional directory. It helps
# in avoiding conflicts or unintended module loading.

!pip install virtualenv 

# create virtual environment 
!virtualenv genai_project

!wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh

#This will help download the miniconda installer script which is used to create
# and manage virtual environments in python

!chmod +x Miniconda3-latest-Linux-x86_64.sh
# this command is making our mini conda installer script executable within
# the colab environment. 

!./Miniconda3-latest-Linux-x86_64.sh -b -f -p /usr/local
# this is used to run miniconda installer script and 
# specify the path where miniconda should be installed

!conda install -q -y --prefix /usr/local python=3.8 ujson
#this will help install ujson and python 3.8 installation in our venv.

import sys
sys.path.append('/usr/local/lib/python3.8/site-packages/')
#it will allow python to locate and import modules from a venv directory

import os
os.environ['CONDA_PREFIX'] = '/usr/local/envs/myenv'

# used to activate miniconda enviornment 

!python --version
#checks the version of python within the activated miniconda environment

Därför skapade vi också vår virtuella miljö i Google Colab. Nu ska vi kolla och se hur vi kan skapa en grundläggande .py-fil där.

!source myenv/bin/activate
#activating the virtual environment

!echo "print('Hello, world!')" >> my_script.py
# writing code using echo and saving this code in my_script.py file

!python my_script.py
#running my_script.py file

Detta kommer att skriva ut Hello World åt oss i utgången. Så det är det. Det handlade om att arbeta med virtuella miljöer i Google Colab. Låt oss nu fortsätta med projektet.

Steg 2: Importera nödvändiga bibliotek

import streamlit as st
import google.generativeaias genai 
import os 
from dotenv import load_dotenv
load_dotenv()
from PIL import Image

Om du har problem med att importera något av ovanstående bibliotek kan du alltid använda kommandot "pip install library_name" för att installera det.

Vi använder Streamlit-biblioteket för att skapa det grundläggande användargränssnittet. Användaren kommer att kunna ladda upp en bild och få utdata baserat på den bilden.

Vi använder Google Generative för att få LLM och analysera bilden för att få kaloriantalet objektmässigt i vår mat.

Bilden används för att utföra en del grundläggande bildförbehandling.

Steg 3: Konfigurera API-nyckeln

Skapa en ny .env-fil i samma katalog och lagra din API-nyckel. Du kan skaffa Google Gemini API nyckel från Google MakerSuite.

Steg 4: Responsgeneratorfunktion

Här kommer vi att skapa en svarsgeneratorfunktion. Låt oss dela upp det steg för steg:

För det första använde vi gener. Konfigurera för att konfigurera API:et som vi skapade från Google MakerSuite-webbplatsen. Sedan gjorde vi funktionen get_gemini_response, som tar in 2 ingångsparametrar: inmatningsprompten och bilden. Detta är den primära funktionen som returnerar utdata i text.

genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))

def get_gemini_response(input_prompt, image):

    model = genai.GenerativeModel('gemini-pro-vision')

    response = model.generate_content([input_prompt, image[0]])

    return response

Här använder vi modellen 'Gemini-pro-vision' eftersom den är multimodal. Efter att ha anropat vår modell från genie.GenerativeModel-beroendet skickar vi bara in vår prompt och bilddata till modellen. Slutligen, baserat på instruktionerna i prompten och bilddata vi matade, kommer modellen att returnera resultatet i form av text som representerar kaloriantalet för olika livsmedel som finns i bilden.

Steg 5: Bildförbehandling

Denna funktion kontrollerar om parametern uploaded_file är Ingen, vilket betyder att användaren har laddat upp en fil. Om en fil har laddats upp fortsätter koden med att läsa filinnehållet i byte med hjälp av getvalue()-metoden för uploaded_file-objektet. Detta kommer att returnera den uppladdade filens råbyte.

Bytedata som erhålls från den uppladdade filen lagras i ett ordboksformat under nyckel-värdeparet "mime_type" och "data." Nyckeln "mime_type" lagrar den uppladdade filens MIME-typ, vilket anger typen av innehåll (t.ex. image/jpeg, image/png). Nyckeln "data" lagrar den uppladdade filens råbyte.

Bilddatan lagras sedan i en lista med namnet image_parts, som innehåller en ordbok med den uppladdade filens MIME-typ och data.

def input_image_setup(uploaded_file):
    if uploaded_file isnotNone:
        #Read the file into bytes
        bytes_data = uploaded_file.getvalue()
        image_parts = [
            {
                "mime_type":uploaded_file.type, 
                "data":bytes_data
            }
        ]
        return image_parts
    else:
        raise FileNotFoundError("No file uploaded")

Steg 6: Skapa användargränssnittet

Så, äntligen, är det dags att skapa användargränssnittet för vårt projekt. Som nämnts tidigare kommer vi att använda Streamlit-biblioteket för att skriva koden för frontend.

## initialising the streamlit app
st.set_page_config(page_title="Calories Advisor App")
st.header("Calories Advisor App")
uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
image = ""
if uploaded_file isnotNone:
    image = Image.open(uploaded_file)
    st.image(image, caption="Uploaded Image", use_column_width=True)
submit = st.button("Tell me about the total calories")

Till en början ställde vi in ​​sidkonfigurationen med set_page_config och gav appen en titel. Sedan skapade vi en rubrik och lade till en filuppladdningsruta där användare kan ladda upp bilder. St. Bild visar bilden som användaren laddade upp till användargränssnittet. Äntligen finns det en skicka-knapp, varefter vi kommer att få utdata från vår stora språkmodell, Gemini Pro Vision.

Steg 7: Skriv systemuppmaningen

Nu är det dags att vara kreativ. Här kommer vi att skapa vår input prompt, och be modellen att fungera som en expert nutritionist. Det är inte nödvändigt att använda prompten nedan; du kan också ge din anpassade prompt. Vi ber vår modell att agera på ett visst sätt för tillfället. Baserat på inmatningsbilden av maten som tillhandahålls ber vi vår modell att läsa dessa bilddata och generera utdata, vilket kommer att ge oss kaloriräkningen för matvarorna som finns i bilden och ge en bedömning av om maten är hälsosam eller ohälsosamt. Om maten är skadlig ber vi den att ge mer näringsrika alternativ till matvarorna i vår bild. Du kan anpassa den mer efter dina behov och få ett utmärkt sätt att hålla koll på din hälsa.

Ibland kanske den inte kan läsa bilddata ordentligt, vi kommer att diskutera lösningar angående detta också i slutet av denna artikel.

input_prompt = """

You are an expert nutritionist where you need to see the food items from the 
image and calculate the total calories, also give the details of all 
the food items with their respective calorie count in the below fomat.

        1. Item 1 - no of calories

        2. Item 2 - no of calories

        ----

        ----

Finally you can also mention whether the food is healthy or not and also mention 
the percentage split ratio of carbohydrates, fats, fibers, sugar, protein and 
other important things required in our diet. If you find that food is not healthy 
then you must provide some alternative healthy food items that user can have 
in diet.

"""
if submit:

    image_data = input_image_setup(uploaded_file)

    response = get_gemini_response(input_prompt, image_data)

    st.header("The Response is: ")

    st.write(response)

Slutligen kontrollerar vi att om användaren klickar på knappen Skicka, kommer vi att få bilddata från

input_image_setup-funktionen som vi skapade tidigare. Sedan skickar vi vår indataprompt och denna bilddata till funktionen get_gemini_response som vi skapade tidigare. Vi anropar alla funktioner vi skapade tidigare för att få den slutliga utdata lagrad som svar.

Steg 8: Installera appen på Hugging Face

Nu är det dags för utplacering. Låt oss börja.

Kommer att förklara det enklaste sättet att distribuera den här appen som vi skapade. Det finns två alternativ som vi kan undersöka om vi vill distribuera vår app: det ena är Streamlit Share och det andra är Hugging Face. Här kommer vi att använda Hugging Face för implementeringen; du kan prova att utforska distributionen på Streamlit Share iFaceu om du vill. Här är referenslänken för det – Implementering på Streamlit Share

Låt oss först snabbt skapa filen requirements.txt som vi behöver för distributionen.

Öppna terminalen och kör kommandot nedan för att skapa en requirements.txt-fil.

pip freeze > requirements.txt1plainText

Detta kommer att skapa en ny textfil med namnet krav. Alla projektberoenden kommer att finnas tillgängliga där. Om detta orsakar ett fel är det okej. Du kan alltid skapa en ny textfil i din arbetskatalog och kopiera och klistra in requirements.txt-filen från GitHub-länken som jag ska tillhandahålla härnäst.

Se nu till att du har dessa filer till hands (eftersom det är vad vi behöver för distributionen):

• app.py
• .env (för API-uppgifterna)
• requirements.txt

Om du inte har en, ta alla dessa filer och skapa ett konto på det kramande ansiktet. Skapa sedan ett nytt utrymme och ladda upp filerna där. Det är allt. Din app kommer att distribueras automatiskt på detta sätt. Du kommer också att kunna se hur implementeringen sker i realtid. Om något fel uppstår kan du alltid ta reda på det med det enkla gränssnittet och, naturligtvis, den kramande ansiktsgemenskapen, som har mycket innehåll för att lösa några vanliga buggar under driftsättning.

Efter en tid kommer du att kunna se appen fungera. Woo ho! Vi har äntligen skapat och implementerat vår app för att beräkna kalorier. Grattis!!, Du kan dela appens fungerande länk med vänner och familj du just byggt.

Här är den fungerande länken till appen som vi precis skapade – The Alorcalorieisor Applikation

Låt oss testa vår app genom att tillhandahålla en indatabild till den:

Innan:

Efter:

Slutför Project GitHub-länk

Här är det kompletta github repository länk som inkluderar källkod och annan användbar information om projektet.

Du kan klona förvaret och anpassa det efter dina krav. Försök att vara mer kreativ och tydlig i din prompt, eftersom detta kommer att ge din modell mer kraft att generera korrekta och korrekta utdata.

Omfattning av förbättring

Problem som kan uppstå i utdata som genereras av modellen och deras lösningar:

Ibland kan det finnas situationer där du inte får rätt utdata från modellen. Detta kan hända på grund av att modellen inte kunde förutsäga bilden korrekt. Om du till exempel ger indatabilder av din mat och din matvara innehåller saltgurka, kan vår modell överväga det som något annat. Detta är det primära problemet här.

• Ett sätt att ta itu med detta är genom effektiva prompt ingenjörstekniker, som få-shot prompt engineering, där du kan mata modellen med exempel, och sedan kommer den att generera utdata baserat på lärdomarna från dessa exempel och den prompt du gav.
• En annan lösning som kan övervägas här är att skapa vår anpassade data och finjustera den. Vi kan skapa data som innehåller en bild av maten i en kolumn och en beskrivning av matvarorna som finns i den andra kolumnen. Detta kommer att hjälpa vår modell att lära sig de underliggande mönstren och förutsäga objekten korrekt i bilden. Därför är det viktigt att få mer korrekta mängder kalorier för bilderna av maten.
• Vi kan ta det längre genom att fråga användaren om hans/hennes näringsmål och be modellen att generera utdata baserat på det. (På detta sätt kommer vi att kunna skräddarsy utdata som genereras av modellen och ge mer användarspecifika utdata.)

Slutsats

Vi har fördjupat oss i den praktiska tillämpningen av Generativ AI inom vården, med fokus på skapandet av Calorie Advisor-appen. Detta projekt visar upp potentialen hos AI för att hjälpa individer att fatta välgrundade beslut om sina matval och upprätthålla en hälsosam livsstil. Från att sätta upp vår miljö till att implementera bildbehandling och snabba tekniska tekniker, vi har täckt de väsentliga stegen. Appens implementering på Hugging Face visar dess tillgänglighet för en bredare publik. Utmaningar som felaktigheter i bildigenkänning åtgärdades med lösningar som effektiv och snabb ingenjörskonst. Som vi avslutar står Calorie Advisor-appen som ett bevis på den transformativa kraften hos Generativ AI för att främja välbefinnande.

Key Takeaways

• Vi har diskuterat mycket hittills, Börjar med projektpipen och sedan en grundläggande introduktion till den stora språkmodellen Gemini Pro Vision.
• Sedan började vi med den praktiska implementeringen. Vi skapade vår virtuella miljö och API-nyckel från Google MakerSuite.
• Sedan utförde vi all vår kodning i den skapade virtuella miljön. Vidare diskuterade vi hur man distribuerar appen på flera plattformar, som Hugging Face och Streamlit Share.
• Bortsett från det har vi övervägt de möjliga problem som kan uppstå och diskuterade lösningar på dessa problem.
•  Därför var det roligt att jobba med det här projektet. Tack för att du stannade till slutet av den här artikeln; Jag hoppas att du får lära dig något nytt.

Vanliga frågor

Medierna som visas i den här artikeln ägs inte av Analytics Vidhya och används efter författarens gottfinnande.

• SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
• PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
• PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
• Platoesg. Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
• PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
• Källa: https://www.analyticsvidhya.com/blog/2024/04/how-to-build-a-calorie-advisor-app-using-genai/