Bazele tehnologiei – Provocarea Technovation

OBIECTIVE DE ÎNVĂȚARE

Identificați straturile unui stack tehnologic și explicați ce face fiecare strat.
Comparați diferite abordări tehnologice și alegeți una potrivită pentru MVP-ul dvs.
Distingeți între abordările LLM (IA generativă) și IA predictivă
Aplicați calea AI adecvată pentru nevoile afacerii dvs.

CE VEȚI CONSTRUI

În funcție de calea AI pe care o alegeți:

Dacă LLM Path: Analizator de feedback optimizat cu setări de temperatură și token
Dacă este calea predictivă: Un analizator de sentimente care clasifică feedback-ul cu scoruri de încredere

IPOTEZE

Studenții au finalizat sintetizarea feedback-ului părților interesate și au realizat cercetări de piață pentru proiectul lor.
Studenții au experiență cu GitHub, Codespaces, localStorage și integrarea API Gemini.

ACTIVITĂȚI

Activitatea 1: Explorați tehnologiile
Activitatea 2: Foaie de lucru pentru decizia privind tehnologia MVP
Activitatea 3a: Calea AI – LLM
Activitatea 3b: Calea AI – Predictivă
Activitatea 3c Provocare: Calea AI – Predictivă (Antrenează-ți propriul model)

Ați creat două module funcționale în setul de instrumente pentru fondatori: un colector de feedback care stochează interviurile cu părțile interesate și un analizator de feedback care utilizează inteligența artificială pentru a identifica tipare în cercetarea dvs.

Acum este momentul să facem un pas înapoi și să înțelegem imaginea de ansamblu a modului în care sunt construite aplicațiile și care abordare tehnologică și AI se potrivește cel mai bine soluției dvs.

În această unitate, vom aborda două alegeri importante în crearea aplicațiilor bazate pe inteligență artificială:

Tech Stack: combinația de instrumente și platforme pentru aplicația dvs.
Calea AI: dacă aveți nevoie de AI pentru generarea de text sau imagini (LLM) sau de AI bazat pe modele (AI predictiv)

Bazele tehnologice

Fiecare aplicație pe care o utilizați – WhatsApp, YouTube, Instagram și Google – este construită cu ajutorul unui tehnologie. Aceasta este combinația de tehnologii care funcționează împreună pentru a face aplicația să funcționeze.

Gândiți-vă la el ca la smartphone-ul dvs.: aveți nevoie de un ecran pentru a vedea lucrurile, un procesor pentru a gândi, spațiu de stocare pentru a vă aminti fotografiile, o baterie pentru alimentare și aplicații pentru a face lucruri utile. Fiecare parte are o funcție diferită, dar toate lucrează împreună pentru a crea ceva util.

În calitate de fondator al unei companii din domeniul tehnologic, este important să înțelegi pe deplin tehnologia pe care o utilizezi, modul în care funcționează și motivul pentru care ai ales-o.

Fiecare aplicație bazată pe inteligență artificială are 5 straturi:

Interfață

Interfața utilizatorului (UI) – tot ceea ce utilizatorul vede, clicuri și interacționează în browserul sau telefonul său.

Exemple:

Web: HTML/CSS/Javascript, React, Vue, Angular, Svelte, Next.js
Mobil: React Native, Flutter, Swift (iOS), Kotlin (Android)
Stil: CSS, Bootstrap, Tailwind

Backend

Logica și creierul – codul de pe partea serverului care procesează cererile utilizatorilor, rulează algoritmi și comunică cu baza de date

Exemple:

Javascript:Node.js
Python: Django, FastAPI
Java: Springboot

Stocare

Memoria – locul în care trăiesc datele

Exemple:

memorie locală
PostgreSQL
MongoDB
Supabase
Firebase

Platforma de implementare

Infrastructura – instrumentele și serviciile care preiau codul dvs. și fac aplicația dvs. disponibilă pe internet

Exemple:

Vercel
Netlify
Căile ferate
Google Cloud
Magazine de aplicații și jocuri (aplicații mobile)

Servicii AI

Inteligența – funcții de informații

Exemple:

Gemenii
OpenAI
Antropic
HuggingFace

Într-o lecție anterioară, am vorbit despre aplicații precum Notion, Duolingo și Grammarly, care utilizează tehnologii complexe cu multiple opțiuni de frontend, backend și stocare. Această complexitate necesită o infrastructură extinsă, deoarece acestea deservesc milioane de utilizatori din întreaga lume.

Dar nu aveți nevoie de un astfel de nivel de complexitate pentru MVP-ul dvs. sau chiar pentru post-MVP.

Stive tehnologice MVP comune

Nu există o singură modalitate „corectă” de a construi un MVP. Iată trei abordări comune:

JavaScript simplu

Ideal pentru: aplicații simple, învățarea noțiunilor fundamentale

Tehnologii: HTML , CSS, JavaScript, Node.js

React/ Typescript

Ideal pentru: aplicații axate pe date, prototipuri rapide

Tehnologii: React , TypeScript, Vite sau Next.js

Python Streamlit

Ideal pentru: aplicații interactive, echipe mai mari

Tehnologii: Python, Streamlit, pandas

Kitul de instrumente pentru fondatori utilizează abordarea Vanilla JavaScript, deoarece este simplă, necesită o configurare minimă și vă învață elementele fundamentale care se aplică oricărui stack.

Atunci când alegeți un stack tehnologic, este recomandat să începeți cu ceea ce cunoașteți. MVP-ul dvs. are nevoie de ceva care funcționează, este ușor de învățat și poate crește odată cu ideea dvs. Puteți face modificări oricând mai târziu.

În această activitate, veți identifica straturile tehnologice din setul de instrumente pentru fondatori și le veți compara cu modul Build Mode al Google AI Studio, care adoptă o abordare diferită în ceea ce privește crearea de aplicații bazate pe inteligență artificială.

ACTIVITATEA 1

Explorați tehnologiile

Timp estimat: 20 minute

1. Deschideți Github și depozitul Founder's Toolkit.

Accesați GitHub și deschideți repo-ul Founder’s Toolkit.
Navigați la ramura principală pentru a vizualiza codul. Nu este necesar să îl deschideți în Codespaces, deoarece doar vizualizăm fișierele.
Căutați fișierele principale în cod:

- index.html: structura HTML
- Fișiere cu extensia .js, cum ar fi script.js sau server.js : aici se află codul Javascript
- Fișiere CSS: interfața utilizatorului care determină aspectul aplicației

Rețineți că structura fișierului dvs. poate fi diferită. De exemplu, Copilot ar fi putut include CSS și Javascript în fișierul dvs. HTML. Dar proiectul dvs. va include cod HTML, CSS și Javascript.

Setul de instrumente al fondatorului dvs. se află cel mai probabil într-un stack JavaScript vanilla care constă din:

- Frontend: HMTL + Javascript + CSS
- Backend: Node.js sau Python
- Stocare: Browser localStorage
- Implementare: Mediu sandbox Codespaces
- AI: Gemini AI

Acesta este un punct de plecare excelent, deoarece funcționează direct în orice browser, nu necesită instrumente complexe de compilare și poate fi modificat cu ușurință.

2. Vedeți o abordare alternativă folosind Google AI Studio

Accesați aistudio.google.com, și căutați Build în meniul din partea stângă a ecranului. Faceți clic pe el.
Introduceți această solicitare în câmpul de sub „Construiți-vă ideile cu Gemini”.Aceasta este aceeași solicitare pe care am folosit-o în Codespaces.

Creați o aplicație simplă care să ajute antreprenorii să colecteze feedback de la 2 părți interesate pentru ideile mele de afaceri preliminare.

Aplicația ar trebui să aibă:

Un titlu în partea de sus: „Setul de instrumente pentru fondatorii AI”.

Un subtitlu: „Începe să colectezi feedback despre problema mea.”

O zonă de text în care pot introduce problema mea

Zone de text în care pot introduce feedback-ul lor pentru fiecare dintre întrebările de mai jos:

Această problemă îi afectează și pe ei?

Ce aspecte consideră ei că sunt cele mai importante?

Ce întrebări sau preocupări vă vin în minte?

Ce îți scapă în legătură cu această problemă?

Un buton intitulat „Trimiteți problema și feedback-ul”.

O zonă de ieșire care afișează problema și feedback-ul

Așteptați până când aplicația generează codul (poate dura câteva minute).

3. Explorați fișierele generate de AIStudio

Faceți clic pe butonul Cod din partea de sus a ecranului pentru a vizualiza fișierele și codul generat.
Ar trebui să arate aproximativ ca în imaginea de mai jos.

În aplicația noastră, Gemini a făcut un pas mai departe și a inclus deja apelul API către Gemini pentru a sintetiza și rezuma, fără nicio solicitare din partea noastră.

Iată o explicație a fișierelor generate, care reprezintă un stack tehnologic React.

Fișierele .tsx sunt Typescript, o formă de Javascript.

index.html & index.tsx configurați mediul și montați aplicația React.
App.tsx gestionează starea globală, gestionează interacțiunile și redă aspectul general.
components/FeedbackSection.tsx este o componentă UI pentru formularul de feedback al părților interesate.
servicii/geminiService.ts este logica pentru comunicarea cu AI-ul Google, definind promptul și solicitând modelului să returneze un obiect JSON structurat.
types.ts definește interfețele TypeScript pentru datele din aplicație.
metadata.json conține informații despre aplicație, cum ar fi titlul și descrierea mediului.

4. Comparați cele două abordări

Păstrați fila Cod deschisă în AIStudio.
Într-o fereastră separată, deschideți depozitul GitHub Founder’s Toolkit și faceți clic pe Code pentru a vizualiza fișierele.
Analizează diferențele dintre codurile celor două aplicații.

Spații de coduri Github

Studio Google AI

Interfață

JavaScript simplu

React + Tailwind CSS (preconfigurat)

Backend

React + Tailwind CSS (preconfigurat)

Gestionat de Google

Stocare

localStorage (browser)

Implementare (deși încă nu am ajuns acolo)

Configurarea platformei de implementare externă și actualizări automate din depozitul Github

Cu un singur clic către Google Cloud

Servicii AI

API Gemini, așa cum este specificat în solicitarea dvs. către Copilot

API Gemini (adăugat automat de AI Studio)

Puteți găsi alte diferențe în cod?

5. Comparați codul de integrare AI

Acum să ne aplecăm asupra diferențelor specifice de cod, concentrându-ne pe codul de integrare AI.

Localizați fișierele specifice în care sunt efectuate apelurile API în ambele platforme.
- Repozitoriu Github: căutați server.js
- Google AI Studio: căutați ceva de genul services/geminiServices.ts
Deschideți ambele fișiere și examinați structura apelului API.
Ambele platforme:
- definește promptul
- trimiteți solicitarea și primiți un răspuns
- verificați dacă există erori
- analizează răspunsul în JSON

Codul înconjurător arată diferit (JavaScript vs TypeScript),dar modelul de integrare AI de bază este același.

Depanare:

Dacă nu găsiți apelul API în codul dvs.: Căutați fetch sau gemini în fișierele JavaScript sau pur și simplu cereți ajutorul Copilot și Google AI Studio Code Assistant pentru a-l găsi.

Dacă aplicația dvs. nu este configurată corect în Google AI Studio: Cereți ajutorul Asistentului de codare.

Ați văzut până acum două platforme diferite cu codificare asistată de IA. Fiecare dintre ele produce stack-uri tehnologice diferite, care fac în esență același lucru.

Cea mai importantă diferență între aceste platforme nu este sintaxa codului, ci modul în care gestionează cheia API Gemini.

Google AI Studio execută apelurile API prin serverele LOR, adăugând cheia API în mod securizat în backend.

Browserul Browser

↓ (trimite cererea cu datele introduse de utilizator)

Frontend-ulAI Studio (codul dvs. React)

↓ (redirecționează către backend-ul AI Studio)

AI StudioServerul (infrastructura Google)

↓ (adaugă cheia API a DVS. din spațiul de stocare securizat al Google)

Gemenii API

↓ (returnează răspunsul)

ServerulAI Studio

↓ (răspuns înapoi)

Browserul Browser (afișează rezultatul)

GitHub Codespaces utilizează arhitectura client-server, în care tu controlezi totul.

Browserul Browser(frontend)

↓ (trimite cererea către backend-ul TĂU)

A ta Express Server (backend-ul pe care îl creați)

↓ (adaugă cheia API din fișierul .env)

Gemenii API

↓ (returnează răspunsul)

A ta Express Express

↓ (răspuns înainte)

Browserul Browser (afișează rezultatul)

Notă: dacă utilizați AI Studio ca platformă de dezvoltare, în cele din urmă va trebui să reproduceți arhitectura client-server a Codespaces pentru a asigura securitatea cheii API Gemini. „Magia” AI Studio funcționează numai în interiorul AI Studio și, în cele din urmă, veți ieși din această platformă, chiar dacă este doar pentru a implementa MVP-ul.

Luați în considerare câteva compromisuri pentru fiecare platformă.

Control

Codespaces vă oferă mai mult control asupra codului dvs.

Confort

AI Studio se ocupă automat de mai multe lucruri pentru tine

Învățare

Construirea în Codespaces te învață cum funcționează lucrurile

Viteză

AI Studio vă ajută să implementați mai rapid o aplicație

Flexibilitate

Spațiile de cod pot fi personalizate în multe moduri

Simplitate

AI Studio are mai multe constrângeri, dar mai puține decizii de luat.

Alegerea tehnologiilor și a strategiei de AI

Acum că ai o idee despre straturile tehnologice, este momentul să iei două decizii importante pentru MVP-ul tău:

Decizia privind tehnologia utilizată: Ce abordare de dezvoltare se potrivește nevoilor dvs.?
Decizia privind calea AI: Ar trebui să utilizați LLM (AI generativ) sau AI predictiv?

Aceste decizii determină modul în care vă construiți aplicația. Nu există un singur răspuns „corect” și fiecare abordare are avantaje și dezavantaje.

Activitatea de mai jos vă va solicita să completați o fișă de lucru, răspunzând la câteva întrebări care ar trebui să vă îndrume către tehnologia potrivită și calea AI pentru proiectul dvs. Nu vă faceți griji că ați putea lua o decizie greșită. Puteți schimba oricând tehnologia folosită. Scopul este să vă construiți MVP-ul în următoarele câteva săptămâni și să obțineți un produs funcțional pe care să îl puteți pune la dispoziția utilizatorilor.

Mentalitatea MVP

Obiectivul tău este să obții cea mai simplă combinație de tehnologii care îți permite să îți testezi ideea. Nu construiești încă o aplicație de producție pentru milioane de utilizatori. Construiești ceva pentru a învăța rapid de la utilizatori reali.

Regula generală:

Dacă nu sunteți sigur de ceea ce aveți nevoie, nu vă faceți griji, deoarece puteți schimba oricând mai târziu. Acest lucru se întâmplă în aplicațiile reale, unde se schimbă tehnologiile pe măsură ce se trece de la idee la producție și nevoile se schimbă în timp.

Ghid de decizie – Tehnologie

Dacă MVP-ul dvs. trebuie să ...

Luați în considerare

De ce pentru un accelerator?

colectează text, afișează rezultate, aspect de bază

Vanilla JavaScript (ceea ce aveți în GitHub)

Cel mai rapid „test de fum”

gestionează mai multe ecrane sau stări complexe ale interfeței utilizatorului

React/TypeScript (ceea ce aveți în Google AI Studio)

Ideal pentru MVP-uri, funcționează pe desktop și dispozitive mobile prin browser

fi construit foarte rapid cu un cod minim

Modul de creare Google AI Studio

Validarea imediată a unei solicitări/logici

rulează ca aplicație mobilă

React Native / Flutter

Un cod sursă care funcționează atât pe iOS, cât și pe Android

Pentru majoritatea MVP-urilor, stiva actuală de JavaScript vanilla este suficientă.

Ghid de decizie – IA

Dacă MVP-ul dvs. trebuie să ...

Luați în considerare

generați text, rezumate sau explicații

LLM

Purtă conversații

LLM

analizează texte nestructurate, cum ar fi documente sau e-mailuri

LLM

clasificați elementele în categorii (de exemplu, dacă un text este pozitiv sau negativ)

Calea AI predictivă cu modele de clasificare

face predicții pe baza datelor (utilizate în marketing și segmentare)

Calea predictivă a IA

punctaj sau clasificare elemente

Calea AI predictivă cu sisteme de recomandare

Pentru majoritatea MVP-urilor, abordarea actuală care utilizează LLM-uri pre-antrenate, precum cele din Founder’s Toolkit, ar trebui să fie suficientă.

ACTIVITATEA 2

Selectați tehnologia și calea AI pentru MVP-ul dvs.

Timp estimat: 30 minute

Acum că înțelegeți instrumentele și alternativele actuale, completați fișa de lucru pentru decizia privind pachetul tehnologic MVP pentru a determina pachetul tehnologic și abordarea AI.

Exersați cu AI Paths

Următoarele activități vă vor oferi ocazia să exersați ambele tipuri de căi AI.

Trebuie să finalizați o singură activitate, în funcție de decizia privind calea AI pe care ați luat-o în foaia de lucru.

Dacă calea ta AI este LLM → finalizează Activitatea 3a
Dacă calea dvs. AI este AI predictivă → finalizați Activitatea 3b
Dacă traseul tău în domeniul IA este „IA predictivă” ȘI intenționezi să-ți creezi propriul model → finalizează Activitatea 3c

Activitatea 3b apelează o API folosind un model pre-antrenat, ceea ce reprezintă o opțiune bună pentru majoritatea proiectelor, atâta timp cât există un model care se potrivește nevoilor dumneavoastră. Acesta ar trebui să fie cazul pentru majoritatea proiectelor.

Vom aborda, de asemenea, antrenarea propriului model în Activitatea 3c pentru orice proiecte care ar putea necesita această abordare.

Setări și costuri AI LLM

Există câteva setări de configurare pe care le puteți seta atunci când apelați o API LLM și care afectează modul în care LLM generează rezultatul.

Temperatură: Cât de creativă vs. consecventă este IA
Jetoane: Unități de text (~3-4 caractere în limba engleză); modul în care IA măsoară intrările/ieșirile
topK / topP: Controlează diversitatea vocabularului (de obicei se lasă la valorile implicite)

În majoritatea cazurilor, concentrați-vă pe temperatură și maxOutputTokens.

Alte setări, precum topK și topP, sunt opțiuni avansate pe care le puteți explora mai târziu.

Temperatura

Temperatura controlează cât de „aleatorii” sau „concentrate” sunt alegerile de cuvinte ale modelului. Gândiți-vă la aceasta ca la un cadran între „jucați la sigur” și „asumați-vă riscuri creative”. Poate fi considerată una dintre cele mai importante setări de înțeles:

Temperatură scăzută (0,1-0,3): Modelul alege aproape întotdeauna cuvântul următor cel mai probabil. Rezultatele sunt consecvente și previzibile.
Temperatură ridicată (0,7-1,0): Modelul este mai dispus să aleagă cuvinte mai puțin evidente. Rezultatele sunt mai variate și mai creative.

Notă importantă: Diferite modele pot utiliza scale diferite. Gemini utilizează 0,0-2,0, în timp ce majoritatea celorlalte modele utilizează 0,0-1,0, așa că asigurați-vă că verificați întotdeauna documentația modelului dvs.

Jetoane

Tokenurile sunt modul în care LLM-urile măsoară textul. Un token are aproximativ 3-4 caractere în limba engleză, dar acest lucru variază în funcție de limbă.

~100 de cuvinte echivalează cu:

Română: 75-100 jetoane
Spaniolă: 80-100 jetoane
Mandarină: 150-200 de jetoane
Hindi: 120-150 jetoane

Tokenurile sunt extrem de importante, mai ales pentru că sunt adesea modalitatea prin care furnizorii de modele AI facturează cererile API. Prin urmare, pentru a controla costurile, este esențial să vă asigurați că utilizați tokenurile în mod eficient și eficient.

Diferite modele percep taxe diferite în funcție de tokenurile trimise în cerere (tokenuri de intrare) și de cele trimise în ieșire (tokenuri de ieșire).

Jetoane de intrare: Ce trimiteți modelului (promptul + contextul)
Jetoane de ieșire: Ce generează modelul înapoi
Prețuri: Majoritatea API-urilor percep o taxă pentru fiecare 1.000 de tokenuri (intrare și ieșire separat)
Limite: Modelele au ferestre de context maxime ferestre contextuale (numărul total de tokenuri care numără solicitările sistemului, intrările și ieșirile) și cereri API (câte apeluri putem efectua pe perioadă, de obicei pe minut).

Nivelurile gratuite sunt de obicei suficient de generoase pentru modelele Gemini și au ferestre contextuale foarte mari, care sunt mai mult decât suficiente chiar și pentru aplicații la nivel de producție, dar ar trebui să fie suficiente pentru MVP-ul dvs.

Regula generală privind tokenul MVP

Solicitări scurte → mai ieftine, mai rapide, mai fiabile

Rezultate scurte → mai ușor de testat și comparat

Mai puține apeluri API → mai ușor de depanat

Pentru MVP-ul tău, urmărește:

1–2 apeluri AI per acțiune a utilizatorului
Rezultate sub ~300 de cuvinte, cu excepția cazurilor în care este absolut necesar

Exemplu: aceeași caracteristică, cost diferit al jetonului

Avertisment privind costurile ridicate:

„Analizează toate transcrierile interviurilor și generează un raport detaliat de 2 pagini de fiecare dată când utilizatorul face clic pe „Trimite”.

Sugestie pentru costuri mai mici:

„Analizează feedback-ul și oferă 3 concluzii cheie și 1 întrebare deschisă.”

A doua versiune este mai ieftină, mai rapidă, mai ușor de evaluat și totuși utilă pentru utilizatori.

Nu vă faceți prea multe griji în legătură cu costurile API-ului AI, deoarece puteți rula multe operațiuni, chiar și în cadrul nivelului gratuit.

Iată un exemplu de cost cu Idea Evaluator din Founder’s Toolkit.

Tokenuri de intrare:

Solicitare sistem: ~200 jetoane
3 soluții cu detalii: ~500 de jetoane fiecare = 1.500 de jetoane
Total introdus ~1.700 jetoane

Jetoane de ieșire:

Analiză și recomandare: ~800 jetoane

Total per analiză: ~2.500 tokenuri
Cost cu Gemini Flash: ~0,0009 $ (mai puțin de 1 cent)

Lunar, cu 100 de utilizatori care analizează de câte 3 ori fiecare:

– 300 de analize × 2.500 de jetoane = 750.000 de jetoane
Cost: ~0,27 $/lună

Acest lucru se încadrează în limitele nivelului gratuit.

ACTIVITATEA 3a

Calea AI - LLM

Timp estimat: 30 minute

Finalizați această activitate dacă ați ales calea LLM AI în foaia de lucru.

În kitul de instrumente pentru fondatori, ați creat un analizator de feedback care utilizează API-ul Gemini. În această activitate, veți personaliza setările AI ale analizatorului de feedback pentru a îmbunătăți calitatea rezultatelor. Veți învăța cum să controlați comportamentul LLM utilizând setările de temperatură și token. Cunoașterea modului de configurare a ambelor este esențială pentru crearea de funcții AI de calitate industrială.

1. Configurarea unei noi ramuri în Github Codespace

Accesați GitHub și deschideți depozitul Founder’s Toolkit.
Creați o nouă ramură din ramura principală și denumiți-o: llm-personalizare
Deschideți spațiul de cod existent din activitățile anterioare.
Verificați noua ramură în spațiul de cod existent. Aceasta păstrează localStorage din execuțiile anterioare ale aplicației dvs.
- În fereastra Terminal din partea de jos a ecranului, tastați (pe linii separate):
  git checkout main
  git pull origin principal
  git checkout -b llm-personalizare

2. Găsiți codul de integrare AI

Găsiți fișierul JavaScript care efectuează apeluri AI (probabil server.js)
Găsiți în cod partea în care efectuați apelul API către Gemini LLM, care ar trebui să includă o instrucțiune de sistem (instrucțiune LLM) și setările de configurare LLM.

Ar trebui să găsiți ceva de genul:

Consultați setarea generationConfig din codul const result. În cazul nostru, temperatura a fost singura setare configurată automat de Copilot. Multe LLM-uri, precum Gemini, au setări implicite utilizate atunci când parametrii de configurare nu sunt furnizați. Cu toate acestea, vă recomandăm să adăugați temperatura și maxOutputTokens ca bună practică.

3. Adăugați codul de configurare LLM

Actualizați codul pentru a seta parametrii de configurare după cum urmează:
- temperatură: 0,8
- maxOutputTokens: 1024

Așa arată codul nostru:

				
					generationConfig: {
  temperature: 0.8,
  maxOutputTokens: 1024,
}

Verificați în server.js dacă codul arată corect.

4. Efectuați mai multe teste

Să facem diverse teste pentru a înțelege impactul.

Rulați Feedback Analyzer cu setările actuale.
Copiați și lipiți rezultatele într-un document separat de fiecare dată când rulați analizorul, astfel încât să puteți compara fiecare rezultat.
Rulați-l din nou cu aceleași setări de configurare.
Comparați rezultatele. Acestea ar trebui să fie foarte similare.
Setați temperatura la 0,2 (creativ) și rulați din nou.
Comparați rezultatele. Rezultatele ar trebui să fie mai variate.
Încercați din nou, de data aceasta schimbând maxOutputTokens la o valoare mai mică, cum ar fi 300.
Comparați rezultatele obținute din răspunsurile mai lungi.

5. Găsiți temperatura ideală

Decideți:

Pentru analizorul dvs. de feedback, care temperatură funcționează cel mai bine?

Dacă doriți o analiză consistentă și fiabilă: utilizați 0,3-0,4.
Dacă doriți mai multe informații creative: utilizați 0,6-0,7

Actualizați codul la temperatura preferată.

6. Confirmați, trimiteți și îmbinați modificările

Confirmați modificările în spațiul dvs. de cod.
Accesați Github, creați o solicitare de extragere și îmbinați modificările cu ramura principală.
Puteți șterge ramura, dar păstrați spațiul de cod.

Acum înțelegeți setările cheie care controlează comportamentul LLM. Când veți crea propriul MVP complet, veți aplica aceste concepte pentru a proiecta funcții AI care se comportă exact așa cum au nevoie utilizatorii dvs.

Dacă nu utilizați niciun tip de IA predictivă în aplicația dvs., puteți trece la secțiunea Reflecție.

Modele de învățare automată pre-antrenate

Un model pre-antrenat este un model pe care altcineva l-a antrenat deja pe baza unor cantități mari de date. Îl puteți utiliza fără a colecta propriile date de antrenare. Utilizarea unui model pentru a face predicții pe baza unor date noi se numește inferență. Așadar, efectuarea unei solicitări API pentru a prezice ceva este o inferență.

Considerații privind costurile: Prețuri predictive pentru IA

AI predictiv se taxează pe apel API sau are un cost unic de instruire. AI predictiv este semnificativ mai ieftin decât LLM pentru sarcini de clasificare. Nivelurile gratuite sunt suficient de generoase pentru toate MVP-urile din acest accelerator.

AI predictivă are un model de stabilire a prețurilor diferit de cel al LLM:

Hugging Face, o platformă pe care o vom folosi în această activitate, oferă cereri API gratuite generoase pe zi, între 1000 și 2000 pe zi (în funcție de model).

Costurile de instruire sunt unice, iar inferența (realizarea de predicții) este mai ieftină la scară largă decât în cazul unui LLM. În timp ce costurile GPU (unitate de procesare grafică) sunt un factor important în instruirea și predicția AI, modelele preinstruite nu necesită costuri GPU. Costul a fost suportat în cadrul instruirii și a fost plătit de altcineva.

Acest tabel vă oferă o idee despre costul clasificării/predicției utilizând un model pre-antrenat în comparație cu utilizarea unui LLM pentru predicție.

Aspect

IA predictivă

LLM (pentru comparație)

Model de stabilire a prețurilor

Per apel API SAU taxă lunară fixă

Pe token (intrare + ieșire)

Costul instruirii

Gratuit (Hugging Face, Teachable Machine)

~0,0001 USD per clasificare

Costul inferenței

Gratuit (1K/zi) sau 9 $/lună nelimitat

N/A (pre-instruit)

Este necesar un GPU?

Nu (furnizorul se ocupă de asta)

La scară largă (10.000/zi)

9 $/lună (tarif fix)

~30-40 $/lună (variabil)

Modelul de analiză a sentimentelor

Pentru Activitatea 3b, vom folosi (cardiffnlp/twitter-roberta-base-sentiment-latest), un model care a fost antrenat pe 124 de milioane de tweet-uri. Acesta clasifică textul în trei categorii:

Pozitiv:fericit, entuziasmat, satisfăcut
Negativ: furios, trist, frustrat
Neutru: factual, nici pozitiv, nici negativ

Modelele AI bazate pe textele de pe Twitter sunt foarte eficiente în analiza sentimentelor, deoarece se bazează pe limbajul real al utilizatorilor și au o amploare foarte mare.

Multe companii de asistență pentru clienți utilizează analiza sentimentelor pentru a analiza sentimentele clienților, în scopul îmbunătățirii aplicațiilor lor, cum ar fi chatbot-urile, sau chiar pentru a îmbunătăți experiența clienților. Acesta ar trebui să fie un model bun pentru a analiza sentimentele din feedback-ul părților interesate.

ACTIVITATEA 3b

AI Path - Predictiv (Analiza sentimentelor)

Timp estimat: 40 minute

Finalizați această activitate dacă ați ales calea AI predictivă în foaia de lucru.

În această activitate, vom adăuga un analizator de sentimente la setul de instrumente pentru fondatori, utilizând un model pre-antrenat, folosind un model de cod similar cu cel pe care l-am utilizat pentru apelurile API folosind modelele Gemini.

1. Creați un cont Hugging Face și creați un token API

Accesați huggingface.co și creați un cont gratuit (dacă nu aveți deja unul).
Faceți clic pe profilul dvs. → Setări → Tokenuri de acces
Faceți clic pentru a crea un nou token, selectați tipul de token „Citire” și atribuiți-i un nume adecvat.
Copiați valoarea tokenului și salvați-o în siguranță.

2. Configurarea unei noi ramuri în Github Codespace

Accesați GitHub și deschideți depozitul Founder’s Toolkit.
Creați o nouă ramură din ramura principală și denumiți-o: sentiment-analysis
Deschideți spațiul de cod existent din activitățile anterioare.
Verificați noua ramură în spațiul de cod existent. Aceasta păstrează localStorage din execuțiile anterioare ale aplicației dvs.
- În fereastra Terminal din partea de jos a ecranului, tastați (pe linii separate):
  git checkout main
  git pull origin principal
  git checkout -b analiza sentimentelor

3. Adăugați tokenul la proiectul dvs.

În mediul Codespaces, adăugați tokenul la mediul dvs.

În fișierul .env, adăugați o linie: HUGGINGFACE_API_KEY=tokenul_dumneavoastră_aici
Lipiți tokenul în codul de mai sus.

O altă metodă

Codespaces are o funcție numită Codespaces Secrets, care permite adăugarea unor elemente precum cheile API pentru a le păstra în siguranță în timpul dezvoltării proiectului.

Accesați repo-ul dvs. din Github.
Faceți clic pe pictograma roată pentru a deschide Setări.
În meniul din partea stângă, faceți clic pe Secrets and Variables (Secrete și variabile), apoi pe Codespaces (Spații de cod).
Adăugați un nou secret pentru HUGGINGFACE_API_KEY cu valoarea tokenului dvs.

Pentru această activitate, ne vom limita la adăugarea cheii în fișierul .env. Cu toate acestea, veți afla mai multe despre GitHub Secrets în unitățile următoare, pentru a spori securitatea aplicației dvs.

4. Adăugați codul de analiză a sentimentelor

Cereți Copilot să adauge această funcție lipind această solicitare.

Adăugați analiza sentimentelor utilizând un model de analiză a sentimentelor preinstruit pentru feedback-ul părților interesate.

Creați o filă nouă numită „Analizator de sentimente”.
Adăugați un câmp de introducere a textului în care utilizatorii pot scrie sau lipi textul feedback-ului.
Adăugați un buton „Analiza sentimentului”
Când este selectat, apelează API-ul Hugging Face Inference:

„https://router.huggingface.co/hf-inference/models/cardiffnlp/twitter-roberta-base-sentiment-latest„

Afișați rezultatul care arată:

– Etichetă (POZITIV sau NEGATIV sau NEUTRU)

– Scorul de încredere exprimat în procente (înmulțiți scorul cu 100)

Am adăugat HUGGINGFACE_API_KEY în fișierul meu .env.

5. Instalați toate pachetele necesare și rulați

Urmați instrucțiunile Copilot pentru a instala pachetele.
Tastați npm start în fereastra terminalului pentru a porni aplicația.

6. Testare cu feedback-ul părților interesate

Odată ce Copilot termină, puteți testa rezultatul cu feedback real din interviurile cu părțile interesate.

Copiați răspunsul unei părți interesate din datele salvate,
Rulați-l prin Analizatorul de sentimente ,
Verity, sentimentul corespunde cu ceea ce te așteptai,

Aplicația ar trebui să vă afișeze răspunsul API ca fiind „pozitiv”, „negativ” sau „neutru”, împreună cu un scor de încredere.

Dacă întâmpinați erori, solicitați ajutorul Copilot sau al unui LLM extern (ChatGPT este eficient în diagnosticarea problemelor API Hugging Face). Iată câteva posibile probleme.

API returnează eroare: Este posibil ca modelul să se încarce sau să aveți probleme de autentificare. Așteptați 20-30 de secunde și încercați din nou sau verificați setările API.
Etichetele sentimentale nu par să se potrivească: Textul neutru este mai greu de clasificat. Încercați exemple mai subiective.

Pentru mai multe informații despre modul de utilizare a acestui model, documentația oficială poate fi găsită aici: https://huggingface.co/cardiffnlp/twitter-roberta-base-sentiment-latest

7. Confirmați, trimiteți și îmbinați modificările

Confirmați modificările în spațiul dvs. de cod.
Accesați Github, creați o solicitare de extragere și îmbinați modificările cu ramura principală.
Puteți șterge ramura, dar păstrați spațiul de cod.

Instruirea și utilizarea propriului model

Pentru majoritatea participanților la acest program de accelerare, nu va fi necesar să construiți propriul model. Există multe modele disponibile, care pot funcționa pentru majoritatea soluțiilor. Cu toate acestea, dacă soluția dvs. se bazează pe clasificarea sau predicția unui element foarte specific pentru problema pe care o rezolvați – de exemplu, identificarea unei plante specifice care există numai în zona dvs. – este posibil să fie necesar să colectați un set de date și să îl utilizați pentru a antrena un model de învățare automată pe care îl puteți implementa în soluția dvs.

În provocarea de mai jos, veți urma întregul proces într-un exemplu cu aplicația Founder’s Toolkit.

Curățați un set de date simplu
Antrenează un clasificator de sentimente folosind AutoTrain de la Hugging Face și un set de date local.
Utilizați modelul din Kitul de instrumente al fondatorului pentru a clasifica sentimentele din feedback-ul părților interesate. Acesta este un proces care implică mai mulți pași.
- Creați un spațiu Hugging Face Gradio
- Creați o demonstrație simplă a modelului dvs. (intrare -> ieșire) în spațiul dvs.
- Spațiul rulează în Python folosim SDK-ul @gradio/client în aplicația noastră React pentru a face legătura între cele două.
- Adăugați codul de conectare al clientului gradio în Founder’s Toolkit pentru a accesa modelul și a afișa rezultatele predicției.

Acest lucru învață întregul flux de lucru al învățării automate:

date → antrenare → evaluare → implementare

ACTIVITATEA 3c

AI Path - Predictiv - Antrenarea propriului model

Timp estimat: 60-90 minute

Finalizați această activitate dacă ați ales calea AI predictivă în foaia de lucru ȘI aveți propriile date.

În cadrul acestei provocări, vom antrena propriul nostru clasificator de sentimente folosind AutoTrain de la Hugging Face.

1. Creați un cont Hugging Face și creați un token API

Poate că ați făcut deja acest lucru dacă ați realizat Activitatea 3B. Dacă nu, urmați pașii de mai jos.

Accesați huggingface.co și creați un cont gratuit (dacă nu aveți deja unul).
Faceți clic pe profilul dvs. → Setări → Tokenuri de acces
Faceți clic pentru a crea un nou token, selectați tipul de token „Citire” și atribuiți-i un nume adecvat.
Copiați valoarea tokenului și salvați-o în siguranță.

2. Exersați curățarea unui set de date

Pentru această activitate, vom utiliza un set de date mare existent de la HuggingFace. Cu toate acestea, atunci când lucrați la propriul proiect, cel mai probabil veți utiliza propriile date. Acești pași vă vor arăta câteva etape de bază pentru a vă asigura că aveți date „curate” pentru un model mai bun.

Creați un folder pe computerul dvs. și denumiți-l sentiment-analysis.
Deschideți această foaie Google și consultați datele din ea.
- Vedeți vreo problemă?
- Verificați dacă există date goale sau lipsă, ID-uri duplicate și etichete inconsistente.
Descărcați fișierul ca fișier .csv (valori separate prin virgulă) din folderul sentiment-analysis. Denumiți-l raw_data.csv.
În același folder, creați un fișier nou cu (TextEdit pe Mac, Notepad pe Windows).
Lipiți codul următor și salvați fișierul ca clean_data.py

				
					import pandas as pd

# ---------- CONFIG ----------
INPUT_FILE = "raw_data.csv"
OUTPUT_FILE = "clean_data.csv"

# ---------- LOAD DATA ----------
df = pd.read_csv(INPUT_FILE)

# ---------- CLEANING STEPS ----------

# 1. Remove rows with missing values
df = df.dropna()

# 2. Remove duplicates
df = df.drop_duplicates()

# 3. Remove irrelevant columns (optional)
# Example: keep only "text" and "label" columns
df = df[["text", "label"]]

# 4. Basic formatting
df["text"] = df["text"].str.strip()     # remove extra spaces
df["text"] = df["text"].str.replace("\n", " ", regex=False)  # remove newlines

# 5. Save cleaned file
df.to_csv(OUTPUT_FILE, index=False)
print(f"Cleaned data saved to {OUTPUT_FILE}")

Uitați-vă la cod și aflați ce face fiecare pas pentru a curăța datele.
Deschideți o fereastră Terminal pe computerul dvs. (nu în Codespaces).
Verificați dacă aveți Python , tastând python
Dacă nu aveți python , accesați aici și descărcați-l și instalați-l.
Navigați la folderul sentiment-analysis din fereastra terminalului folosind comanda cd . Căutați ajutor online dacă aveți nevoie.
Odată ce vă aflați în folderul sentiment-analysis, tastați pip install pandas (sau pip3 install pandas dacă nu recunoaște pip). Aceasta instalează biblioteca pandas, biblioteca de analiză python .
Odată instalat, tastați python .py sau python3 clean_data.py (în funcție de versiunea de python pe care python instalată). Aceasta execută codul din python pe care tocmai l-ați creat.
Așteptați mesajul „Datele curățate au fost salvate în clean_data.csv”, apoi localizați clean_data.csv și deschideți-l cu un editor de text sau, dacă aveți Excel.
Rețineți modificările din fișier. Datele lipsă, duplicatele și etichetele eronate trebuie corectate.

Acesta este doar un exercițiu pentru a vă arăta pașii necesari pentru curățarea propriilor date. Pentru restul activității, vom folosi un set de date mult mai mare, pe care îl vom descărca de pe HuggingFace.

3. Descărcați un set de date text

Pentru a emula utilizând propriul set de date, vom descărca un set de date mare de la Hugging Face sub formă de fișiere csv, pe care le veți utiliza pentru a antrena un model folosind Hugging Face AutoTrain. AutoTrain este o metodă automată (și cu costuri reduse/fără costuri) de antrenare și implementare a modelelor de învățare automată de ultimă generație, integrată perfect în ecosistemul Hugging Face.

Accesați Seturi de date Hugging Face.
Lângă Seturi de date, unde scrie Filtrează după nume, tastează syedkhalid076/Analiza sentimentelor.
Vom folosi acest set de date deoarece este mare și are aceleași etichete pe care le dorim pentru Founder’s Toolkit: negativ, neutru și pozitiv.

Ar trebui să vedeți 2 seturi de date listate. Faceți clic pe al doilea set de date și examinați fișa setului de date pentru a afla mai multe despre acesta și pentru a vedea câteva exemple de date.
Faceți clic pe Fișiere și versiuni pentru a vedea fișierele asociate setului de date.
Vom avea nevoie de date de antrenare și validare, așa că faceți clic pentru a descărca train_data.csv și val_data.csv.
Mutați ambele fișiere în folderul de analiză a sentimentelor. Deschideți-le pentru a vedea cum arată datele.
Autotrain necesită denumiri speciale pentru fișierele de date. Redenumiți train_data.csv → train.csv și redenumiți val_data.csv → valid.csv.

4. Configurați Google Colab pentru a vă antrena modelul

Puteți încerca să utilizați HuggingFace AutroTrain Spaces pentru a vă antrena direct pe platforma lor, dar platforma poate fi capricioasă, mai ales dacă utilizați versiunea gratuită. Există, de asemenea, opțiunea de a vă antrena local pe computerul dvs., instalând autotrain, dar acest lucru necesită un computer decent, cu o putere CPU bună. Pentru a evita orice probleme la nivel local, vom folosi puterea Google Colab, care vă permite să creați un notebook Colab și să rulați Python în cloud, profitând de puterea GPU-urilor Google.

Accesați acest repozitoriul GitHub pentru Autotrain Advanced.
Derulați în jos README și găsiți Clasificarea textului sub Sarcini acceptate.
Faceți clic pe linkul Clasificare text pentru a deschide în Colab.
Se va deschide un notebook Google Colab. Faceți clic pe Copiere în Drive pentru a salva o copie în propriul Google Drive.
În partea de sus, redenumiți caietul în „sentiment-analysis-model.ipynb”
Faceți clic pe meniul Runtime din partea de sus și alegeți Change Runtime type(Modificare tip Runtime).
Alegeți GPU T4 și faceți clic pe Salvare. Este posibil să vi se solicite să reporniți notebook-ul. Faceți acest lucru dacă vi se solicită. Astfel veți beneficia de puterea GPU pentru o instruire mai rapidă.

5. Copiați setul de date în caietul Colab

În meniul din partea stângă, faceți clic pe pictograma folderului pentru a deschide Managerul de fișiere. Veți vedea un folder numit sample_data. Faceți clic pe el și redenumiți-l date.
Deschideți folderul. Veți vedea mai multe fișiere csv și json.
Trageți fișierele train.csv și valid.csv pe care le-ați descărcat de pe HuggingFace în folder.

6. Configurați caietul Colab pentru a antrena modelul

Deși vi se oferă câteva exemple de cod, trebuie să efectuați câteva actualizări pentru a configura datele și modelul dvs.

Plasați cursorul între primele două blocuri de text/cod, numite celule. Ar trebui să vedeți butoanele +Cod și +Text. Faceți clic pe +Cod pentru a crea o celulă de cod goală.
Tip !pip install autotrain-advanced în celulă.
Aceasta va instala pachetul autotrain-advanced în notebook-ul dvs. Simbolul ! din fața comenzii este similar cu executarea unei comenzi terminal din interiorul notebook-ului.
Faceți clic pe săgeata din partea stângă a celulei pentru a rula comenzile din interiorul celulei. Așteptați instalarea pachetului autotrain-advanced.
Faceți clic pe săgeata din celula următoare de mai jos pentru a importa aceste biblioteci.
În celula următoare, trebuie să configurăm numele de utilizator și parola pentru HuggingFace. Înlocuiți your_huggingface_username cu numele dvs. de utilizator HuggingFace real.
În loc să introducem tokenul direct în notebook, să fim mai siguri ascunzându-l. Înlocuiți
HF_TOKEN = „your_huggingface_write_token” cu
HF_TOKEN = getpass(„Introduceți tokenul HF: „)
Rulați codul celulei făcând clic pe săgeată. Vi se va solicita să introduceți tokenul Hugging Face. Copiați și lipiți tokenul când vi se solicită.

Tokenul rămâne ascuns, dar va trebui reintrodus dacă închideți și redeschideți notebook-ul.

7. Actualizați parametrii pentru antrenament

Iată codul furnizat. Majoritatea setărilor implicite ne vor fi utile, dar trebuie să modificăm câteva lucruri.

				
					params = TextClassificationParams(
   model="google-bert/bert-base-uncased",
   data_path="stanfordnlp/imdb", # path to the dataset on huggingface hub
   text_column="text", # the column in the dataset that contains the text
   target_column="label", # the column in the dataset that contains the labels
   train_split="train",
   valid_split="test",
   epochs=3,
   batch_size=8,
   max_seq_length=512,
   lr=1e-5,
   optimizer="adamw_torch",
   scheduler="linear",
   gradient_accumulation=1,
   mixed_precision="fp16",
   project_name="autotrain-model",
   log="tensorboard",
   push_to_hub=True,
   username=HF_USERNAME,
   token=HF_TOKEN,
)

data_path se referă în prezent la un set de date de pe Hugging Face. Vrem să indicăm fișierele noastre csv „locale”. Așadar, setați calea la „data”.
Adăugați 2 linii sub linia data_path.
train_split=”train”,
valid_split=”valid”,
Acestea indică cele două fișiere .csv pentru datele de antrenare și validare.
coloană_text și target_column corespund cu ceea ce avem în fișierele noastre .csv. Așadar, păstrați-le așa cum sunt.
Schimbați numele proiectului cu un nume adecvat, cum ar fi sentiment-analysis-model.
Restul parametrilor sunt în regulă așa cum sunt. Faceți clic pe săgeată pentru a rula celula.
Săriți peste următoarea celulă. Este doar informativă.
Rulați celula care conține acest cod:
project = AutoTrainProject(params=params, backend=”local”, process=True)
project.create().
Acest lucru va începe antrenarea modelului.

Aveți răbdare și țineți fereastra deschisă pe computerul dvs.
Antrenarea modelului poate dura între 30 de minute și peste o oră.

8. Localizați modelul dvs. pe Hugging Face

Odată ce modelul a terminat antrenamentul, accesați contul Hugging Face și faceți clic pe profilul dvs. Ar trebui să aveți un model nou cu numele pe care i l-ați dat în caietul Colab.
După ce găsiți modelul, faceți clic pe nume pentru a-l deschide.
Faceți clic pe Setări și setați-l ca Public. Astfel, acesta va fi ușor accesibil atunci când creați un pipeline pentru modelul dvs.

9. Creați un nou spațiu Hugging Face

În partea de sus a ferestrei Hugging Space, faceți clic pe Spații.
Faceți clic pe buton + Spațiu nou.
Dă-i spațiului tău un nume adecvat, cum ar fi founders-toolkit-sentiment-analysis.
Pentru Space SDK, selectați Gradio, iar pentru Space Hardware, selectați CPU Basic.
Asigurați-vă că spațiul dvs. este setat la Public și creați spațiul.
Faceți clic pe Fișiere în partea de sus a ecranului. Aceasta vă arată fișierele din spațiul dvs. Rețineți că arată foarte mult ca un depozit Github.
Trebuie să adăugați fișierele pentru a rula modelul. Faceți clic pe Contribuie și Creați un fișier nou.

8. Lipiți următorul cod:

				
					import gradio as gr
from transformers import pipeline


classifier = pipeline("text-classification", 
 model="HF_USERNAME/HF_MODELNAME")


def predict(text):
   return classifier(text)


with gr.Blocks() as demo:
   text_input = gr.Textbox(label="Input Text")
   output = gr.JSON(label="Prediction")


   text_input.submit(predict, inputs=text_input, outputs=output)


demo.launch()

În linia de cod cu model=, introduceți numele de utilizator Hugging Face și numele modelului.
Puteți obține acest șir de caractere cu ușurință făcând clic pe profilul dvs. din Hugging Face, apoi făcând clic pe model. Puteți copia numele/modelul dvs. din partea de sus a paginii modelului.
Denumiți acest fișier app.py
Faceți clic din nou pe numele spațiului de lângă ramura principală pentru a reveni la lista de fișiere. Faceți clic pe Contribute (Contribuie) și creați din nou un fișier nou.
Acesta va fi fișierul dvs. requirements.txt, care indică python biblioteci să încarce atunci când rulează spațiul.
Lipiți:
transformers
torch
în fișier. Denumiți-l requirements.txt.

10. Începeți spațiul dvs.

Faceți clic pe App în partea de sus a ecranului, iar aplicația/spațiul ar trebui să pornească.
Este posibil să dureze câteva minute până când aplicația dvs. va porni. În cele din urmă, ar trebui să vedeți un buton verde Running (În execuție) în partea de sus a ecranului.
Puteți testa modelul introducând ceva în blocul de text de introducere și veți obține predicția mai jos.

Rețineți că, atunci când îl rulați, acesta vă oferă o etichetă și un scor. Eticheta poate fi 0, 1 sau 2. 0 = negativ, 1 = neutru și 2 = pozitiv. Scorul reprezintă nivelul de încredere pentru predicție. Acesta variază de la 0 la 1, 1 reprezentând un nivel de încredere complet în predicție.

11. Adăugați la setul de instrumente al fondatorului

Această parte poate fi dificilă, dar colaborați cu Copilot (sau alte LLM-uri) pentru a o implementa.

Deschideți o nouă ramură în depozitul Github.
Deschideți spațiul de lucru Github Codespace.
Verificați noua ramură.
Rulați această comandă în fereastra terminalului pentru a instala biblioteca gradio.
npm install @gradio/client
Utilizați promptul de mai jos cu Copilot, înlocuind MY_HF_USERNAME și MY_HF_SPACE cu numele dvs. de utilizator și spațiul dvs. pe Hugging Face (rețineți că acestea apar în două locuri).

Adăugați o filă „Analizator de sentimente” în aplicație. Aceasta trebuie să conțină un câmp de text pentru introducerea datelor de către utilizator și un buton „Analizează sentimentul”.

Apăsarea butonului ar trebui să inițieze un apel către Hugging Face Gradio Space MY_HF_USERNAME/MY_HF_SPACE (fără backend).

Răspunsul din spațiul Gradio ar trebui să afișeze eticheta și scorul.

Constrângeri:

Integrare numai pentru client; nu modificați server.js și nu adăugați noi puncte finale.

Utilizați @gradio/client prin ESM de la jsdelivr; asigurați-vă că există o singură cale de import și expuneți window.GradioClient.

Consolidați într-o singură metaetichetă CSP. Permiteți: connect-src „self” https://generativelanguage.googleapis.com https://*.hf.space https://huggingface.co wss://*.hf.space; script-src „unsafe-inline” https://cdn.jsdelivr.net; style-src „unsafe-inline”.

Apelați spațiul cu Client.connect(‘MY_HF_USERNAME/MY_HF_SPACE’) și predict(‘/predict’, [text]).

Maparea ieșirii:

Etichete hartă: 0 → negativ, 1 → neutru, 2 → pozitiv

Scorul variază între 0 și 1. Se exprimă ca procent cu două zecimale.

Testați aplicația după ce Copilot generează codul corespunzător. Remediați eventualele probleme apărute. Introduceți un comentariu negativ aleatoriu și vedeți rezultatul, apoi încercați unul pozitiv.

12. Confirmați, trimiteți și îmbinați modificările

Odată ce sunteți mulțumit de rezultate:

Confirmați modificările în spațiul dvs. de cod.
Accesați Github, creați o solicitare de extragere și îmbinați modificările cu ramura principală.
Puteți șterge ramura, dar păstrați spațiul de cod.

NOTĂ: Această activitate și utilizarea Hugging Face Spaces au scopul de a vă arăta o metodă cu costuri reduse sau chiar fără costuri pe care o puteți folosi pentru a integra propriul model într-o aplicație. Am folosit frontend-ul și conexiunea clientului și am păstrat atât modelul nostru, cât și spațiul Hugging Face publice, pentru a simplifica testarea. Cu toate acestea, dacă antrenați propriul model folosind Hugging Face AutoTrain și spațiile Hugging Face, rețineți că va trebui să asigurați un nivel mai ridicat de securitate prin utilizarea unui server backend (server.js) și să vă securizați tokenul folosind fișierul .env.

Reflecție

Ai aflat mai multe despre stack-urile tehnologice și traseele de dezvoltare în domeniul IA și ai luat câteva decizii legate de produsul tău. Iată câteva aspecte de luat în considerare:

01 Stiva tehnologică a site-ului

Având în vedere cerințele MVP-ului tău, care abordare tehnică este cea mai potrivită pentru proiectul tău: JavaScript „vanilla” sau un framework precum React? De ce?

02 Calea AI „

”

Aplicația ta are nevoie în primul rând să genereze conținut (LLM) sau să clasifice/prevadă (IA predictivă)? Care a fost caracteristica specifică care a determinat această decizie?

03 Compromisuri legate de „

”

Care este un avantaj și un dezavantaj al abordării bazate pe IA pe care ați ales-o?

04 Prezentarea „

”

Cum ai explica într-o singură propoziție alegerile tale tehnologice unui investitor fără cunoștințe tehnice?

Termeni cheie

Tech Stack: Combinația de limbaje de programare, cadre și servicii utilizate pentru a crea aplicația dvs.
Frontend: Ceea ce văd și cu ce interacționează utilizatorii (HTML, CSS, JavaScript, React)
Backend: Codul de pe partea serverului care procesează datele și execută logica
API (Interfață de programare a aplicațiilor): O modalitate prin care codul dvs. poate comunica cu servicii externe.
LLM (model lingvistic de mari dimensiuni): IA care generează text, poartă conversații și analizează documente
AI predictivă: IA care identifică tipare în date pentru a face predicții sau clasificări
Temperatură (setare AI): Controlează cât de creative sau consecvente sunt răspunsurile AI (0 = previzibile, 1 = creative)
Inferență: Utilizarea unui model antrenat pentru a face predicții pe baza datelor noi
Instruire: Învățarea unui model să recunoască tipare prin prezentarea de exemple etichetate
Model pre-antrenat: Un model deja antrenat pe seturi mari de date, gata de utilizare.
AutoTrain: O platformă care antrenează automat modele ML fără codificare

Resurse suplimentare

Google AI Studio – Mod de construire pentru prototipuri rapide
Clasificare | Învățare automată | Google pentru dezvoltatori
Analiza sentimentelor | API Cloud pentru limbaj natural
Înțelegerea și numărarea tokenurilor | API Gemini | Google AI pentru dezvoltatori
Documentație client Gradio JS
Hugging Face AutoTrain – Antrenarea modelelor fără cod
Setul de date privind sentimentul pe Twitter – Setul de date utilizat în Activitatea 3b
API-ul de inferență Hugging Face – Cum se apelează modelele prin API
Tutorial privind analiza sentimentelor pe Twitter – Tutorial detaliat cu exemple de cod

Conținutul lecției

Chestionar anterior

Înapoi la curs

Următorul test