Quantenmechanik ist eine grundlegende Theorie der Physik, die Phänomene auf mikroskopischer Ebene (wie Atome und subatomare Teilchen) erklärt. Dieses „neue“ (1900) Fachgebiet unterscheidet sich von der klassischen Physik, die die Natur auf makroskopischer Ebene beschreibt (wie Körper und Maschinen) und nicht auf der Quantenebene gilt.

Quantencomputing ist die Ausnutzung der Eigenschaften der Quantenmechanik, um Berechnungen durchzuführen und Probleme zu lösen, die ein klassischer Pc nicht kann und niemals lösen kann.

Normale Pc sprechen das Binärcode Sprache: Sie weisen jedem Zeichen und jeder Anweisung ein Muster aus binären Ziffern (1en und 0en) zu und speichern und verarbeiten diese Informationen in Bits. Sogar Ihr Python-Code wird in Binärziffern übersetzt, wenn er auf Ihrem Laptop computer ausgeführt wird. Zum Beispiel:

Das Wort „Hello“ → „h“: 01001000 und „ich“: 01101001 → 01001000 01101001

Auf der anderen Seite verarbeiten Quantencomputer Informationen mit Qubits (Quantenbits), die gleichzeitig 0 und 1 sein können. Das macht Quantenmaschinen für bestimmte Probleme (z. B. probabilistische Berechnungen) erheblich schneller als normale.

Quantencomputer

Quantencomputer nutzen Atome und Elektronen anstelle klassischer Chips auf Siliziumbasis. Dadurch können sie die Quantenmechanik nutzen, um Berechnungen viel schneller als normale Maschinen durchzuführen. Beispielsweise reichen 8 Bits für einen klassischen Pc aus, um jede Zahl zwischen 0 und 255 darzustellen, aber 8 Qubits reichen für einen Quantencomputer aus, um jede Zahl zwischen 0 und 255 darzustellen gleichzeitig. Ein paar hundert Qubits würden ausreichen, um mehr Zahlen darzustellen, als es Atome im Universum gibt.

Das Gehirn eines Quantencomputers ist winzig Qubit-Chip aus Metallen oder Saphir.

Der ikonischste Teil ist jedoch die große Kühlvorrichtung aus Gold, die wie ein Kronleuchter aussieht, der in einem Stahlzylinder hängt: der Verdünnungskühlschrank. Es kühlt den Chip auf eine Temperatur ab, die kälter als der Weltraum ist, da Wärme Quantenzustände zerstört (grundsätzlich gilt: Je kälter es ist, desto genauer wird es).

Das ist die führende Artwork von Architektur und nennt sich supraleitende Qubits: künstliche Atome, die aus Schaltkreisen mit Supraleitern (wie Aluminium) hergestellt werden, die bei extrem niedrigen Temperaturen keinen elektrischen Widerstand aufweisen. Eine various Architektur sind Ionenfallen (geladene Atome, die in elektromagnetischen Feldern im Ultrahochvakuum gefangen werden), die genauer, aber langsamer als erstere sind.

Es gibt keine genaue öffentliche Zählung darüber, wie viele Quantencomputer es gibt, Schätzungen gehen jedoch von rund 200 weltweit aus. Die derzeit fortschrittlichsten sind:

1. IBMs Kondordie größte bisher gebaute Qubit-Anzahl (1000 Qubits), auch wenn dies allein keine sinnvolle Berechnung darstellt, da Fehlerraten immer noch eine Rolle spielen.
2. Googles Willow (105 Qubits), mit guter Fehlerrate, aber immer noch weit entfernt von fehlertolerantem Computing im großen Maßstab.
3. IonQs Tempo (100 Qubits), Ionenfallen-Quantencomputer mit guten Fähigkeiten, aber immer noch langsamer als supraleitende Maschinen.
4. Quantinuums Helios (98 Qubits) verwendet eine Ionenfallenarchitektur mit einer der höchsten Genauigkeiten, über die heute berichtet wird.
5. Rigetti Computing Ankaa (80 Qubits).
6. Intels Tunnelfälle (12 Qubits).
7. Kanada Xanadus Aurora (12 Qubits), der erste photonische Quantencomputer, der Licht anstelle von Elektronen zur Informationsverarbeitung verwendet.
8. Microsofts Majoranader erste Pc, der für eine Skalierung auf eine Million Qubits auf einem einzigen Chip ausgelegt ist (derzeit verfügt er jedoch über 8 Qubits).
9. chinesisch SpinQs Minider erste tragbare kleine Quantencomputer (2 Qubits).
10. NVIDIAs QPU (Quantenverarbeitungseinheit), das erste GPU-beschleunigte Quantensystem.

Im Second ist es für einen normalen Menschen unmöglich, einen großen Quantencomputer zu besitzen, aber man kann über die Cloud darauf zugreifen.

Aufstellen

In Python gibt es mehrere Bibliotheken für die Arbeit mit Quantencomputern auf der ganzen Welt:

• Qiskit von IBM ist das umfassendste Excessive-Stage-Ökosystem zum Ausführen von Quantenprogrammen auf IBM Quantencomputern, perfekt für Anfänger.
• Cirq von Google, das sich der Low-Stage-Kontrolle seiner {Hardware} widmet und besser für die Forschung geeignet ist.
• PennyLane von Xanadu ist auf Quantum Machine Studying spezialisiert und läuft auf proprietären photonischen Computern, kann aber auch mit anderen Anbietern verbunden werden.
• ProjektQ von der ETH Zürich, einem Open-Supply-Projekt, das versucht, das wichtigste Allzweckpaket für Quantencomputing zu werden.

Für dieses Tutorial werde ich IBM verwenden Qiskit da es der Branchenführer ist (pip set up qiskit).

Der einfachste Code, den wir schreiben können, besteht darin, einen zu erstellen Quantenschaltung (Umgebung für Quantenberechnungen) mit nur einem Qubit und initialisieren Sie es als 0. Um den Zustand des Qubits zu messen, benötigen wir ein Zustandsvektorwas Ihnen im Grunde die aktuelle Quantenrealität Ihrer Schaltung verrät.

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

q = QuantumCircuit(1,0) #circuit with 1 quantum bit and 0 basic bit
state = Statevector.from_instruction(q) #measure state
state.possibilities() #print prob%

Das bedeutet: Die Wahrscheinlichkeit, dass das Qubit 0 ist (erstes Ingredient), beträgt 100 %, während die Wahrscheinlichkeit, dass das Qubit 1 ist (zweites Ingredient), 0 % beträgt. Sie können es so ausdrucken:

print(f"(q=0 {spherical(state.possibilities()(0)*100)}%, 
         q=1 {spherical(state.possibilities()(1)*100)}%)")

Lassen Sie uns den Zustand visualisieren:

from qiskit.visualization import plot_bloch_multivector

plot_bloch_multivector(state, figsize=(3,3))

Wie Sie der 3D-Darstellung des Quantenzustands entnehmen können, ist das Qubit zu 100 % bei 0. Das conflict das Quantenäquivalent von „Hallo Welt“, und jetzt können wir zum Quantenäquivalent von „ übergehen1+1=2„.

Qubits

Qubits haben zwei grundlegende Eigenschaften der Quantenmechanik: Überlagerung und Verschränkung.

Überlagerung — klassische Bits können entweder 1 oder 0 sein, aber niemals beides. Im Gegenteil, ein Qubit kann beides sein (technisch gesehen ist es eine lineare Kombination einer unendlichen Anzahl von Zuständen zwischen 1 und 0), und nur wenn es gemessen wird, bricht die Überlagerung auf 1 oder 0 zusammen und bleibt für immer so. Dies liegt daran, dass die Beobachtung eines Quantenteilchens es dazu zwingt, einen klassischen binären Zustand von entweder 1 oder 0 anzunehmen (im Grunde die Geschichte von Schrödingers Katze die wir alle kennen und lieben). Daher hat ein Qubit eine gewisse Wahrscheinlichkeit, auf 1 oder 0 zu kollabieren.

q = QuantumCircuit(1,0)
q.h(0) #add Superposition
state = Statevector.from_instruction(q) 
print(f"(q=0 {spherical(state.possibilities()(0)*100)}%, 
         q=1 {spherical(state.possibilities()(1)*100)}%)")
plot_bloch_multivector(state, figsize=(3,3))

Mit der Überlagerung haben wir „Zufälligkeit“ eingeführt, sodass der Vektorzustand zwischen 0 und 1 liegt. Anstelle einer Vektordarstellung können wir eine q-Kugel verwenden, bei der die Größe der Punkte proportional zur Wahrscheinlichkeit des entsprechenden Termes im Zustand ist.

from qiskit.visualization import plot_state_qsphere

plot_state_qsphere(state, figsize=(4,4))

Das Qubit ist sowohl 0 als auch 1, mit jeweils 50 % Wahrscheinlichkeit. Aber was passiert, wenn wir messen Es? Manchmal ist es eine feste 1 und manchmal eine feste 0.

consequence, collapsed = state.measure() #Superposition disappears
print("measured:", consequence)
plot_state_qsphere(collapsed, figsize=(4,4)) #plot collapsed state

Verstrickung — Klassische Bits sind unabhängig voneinander, während Qubits miteinander verschränkt sein können. Wenn das passiert, sind Qubits unabhängig von der Entfernung für immer korreliert (oft als mathematische Metapher für Liebe verwendet).

q = QuantumCircuit(2,0) #circuit with 2 quantum bits and 0 basic bit
q.h((0)) #add Superposition on the first qubit
state = Statevector.from_circuit(q) 
plot_bloch_multivector(state, figsize=(3,3))

Wir haben das erste Qubit in Superposition zwischen 0-1, das zweite bei 0, und jetzt werde ich sie verschränken. Wenn additionally das erste Teilchen gemessen wird und auf 1 oder 0 kollabiert, ändert sich auch das zweite Teilchen (nicht unbedingt zum gleichen Ergebnis, eines kann 0 sein, während das andere 1 ist).

q.cx(control_qubit=0, target_qubit=1) #Entanglement
state = Statevector.from_circuit(q)
consequence, collapsed = state.measure((0)) #measure the first qubit
plot_bloch_multivector(collapsed, figsize=(3,3))

Wie Sie sehen können, wurde das erste Qubit, das sich in Superposition befand, gemessen und auf 1 kollabiert. Gleichzeitig ist das zweite Quibit mit dem ersten verschränkt und hat sich daher ebenfalls verändert.

Abschluss

Dieser Artikel conflict ein Tutorial zu Einführung in die Grundlagen des Quantencomputings mit Python und Qiskit. Wir haben gelernt, wie man mit Qubits und ihren zwei grundlegenden Eigenschaften arbeitet: Superposition und Verschränkung. Im nächsten Tutorial werden wir Qubits verwenden, um Quantenmodelle zu erstellen.

Vollständiger Code für diesen Artikel: GitHub

Ich hoffe, es hat Ihnen gefallen! Kontaktieren Sie mich gerne für Fragen und Suggestions oder einfach nur, um mir Ihre interessanten Projekte mitzuteilen.

Lassen Sie uns verbinden

_{^{(Alle Bilder stammen vom Autor, sofern nicht anders angegeben)}}

Angenommen, in Ihrem Mobiltelefon befindet sich ein intelligenter Pc. Es reagiert sofort, kennt Ihre Sprache und ist auch ohne Web voll funktionsfähig. Diese KI wird Ihre Informationen auf Ihrem Gerät vertraulich behandeln. Es ist keine zusätzliche Gebühr professional Frage erforderlich. Das ist die Zukunft, die Sarvam Edge in Indien schafft.

Sarvam Edge ist eine Type der KI, die unsere Geräte mit Strom versorgt und unsere Beziehung zur Technologie, wie wir sie kennen, verändert. Dieser Leitfaden zeigt Ihnen, was Sarvam Edge ist und wozu es fähig ist. Mithilfe einer einfachen praktischen Anleitung können Sie noch heute mit dem Bau beginnen.

Lesen Sie auch: Neues Replace macht GPT-5.3 sofort nützlicher für alltägliche Aufgaben

Warum On-System-KI ein Recreation-Changer ist

Sarvam Edge befasst sich mit den Schlüsselproblemen cloudbasierter KI. Es überträgt die Intelligenz direkt von Distant-Servern auf das Handheld-Gadget. Dies ermöglicht eine bessere Benutzererfahrung.

Deshalb ist das wichtig:

• Sofortige Reaktion (geringe Latenz): Die KI wird auf Ihrem Gerät bereitgestellt. Es gibt keine Verzögerung. Dies ist für die nahtlosen Sprachassistenten und Stay-Übersetzer von entscheidender Bedeutung.
• Volle Privatsphäre: Die gesamte Verarbeitung erfolgt auf der lokalen Seite. Ihre Daten verlassen Ihr Gerät nicht und Ihre Stimme auch nicht. Dies gewährleistet absolute Privatsphäre.
• Überall und jederzeit: Sarvam Edge benötigt kein Web. Bei schlechten Verbindungen ist es zuverlässig. Es funktioniert sogar während eines Fluges.
• Keine Kosten professional Abfrage: Die KI verbraucht die {Hardware} Ihres Geräts. Dadurch entfallen die Nutzungsgebühren für Cloud-APIs. Es ist erschwinglich, sodass jeder auf KI-Instruments zugreifen kann.

Lesen Sie auch: 20 OpenClaw-Eingabeaufforderungen zur Automatisierung Ihres täglichen Lebens und Ihrer Arbeit

Sarvam Edge: Ein tiefer Einblick in die Leistung

Die Sarvam Edge-Modelle sind leistungsstark, aber klein. Sie sind hardwareoptimiert auf Shopper-{Hardware}. Sie haben das Potenzial, das sich in Leistungsdaten widerspiegelt.

Spracherkennung auf dem Gerät

Sarvam hatte ein Modell entwickelt, das zehn große indische Sprachen beherrscht. Es ist clever zu wissen, in welcher Sprache Sie sich unterhalten.

• Modellgröße: 74 Millionen Parameter.
• Geräte-Footprint: ~294 MB.
• Geschwindigkeit: Auf einem Qualcomm Snapdragon 8 Gen 3 reagiert es in weniger als 300 Millisekunden. Es verarbeitet Audio 8,5-mal schneller als in Echtzeit.

Dies ist eine der Stärken des Modells. Es wurde anhand des Vistaar-Benchmark-Units bewertet. Die Ergebnisse deuten darauf hin, dass die Zeichenfehlerrate (CER) niedrig ist und je niedriger die Punktzahl, desto besser.

Das Sarvam Edge-Modell übertrifft in der Regel Google STT, wie in der Tabelle angegeben. Es zeigt eine gute Genauigkeit in Sprachen wie Bengali, Hindi und Punjabi. Dies macht es zu einer zuverlässigen Possibility zum Verstehen indischer Stimmen.

Lesen Sie auch: Bulbul-V2 von Sarvam AI: Indiens bestes TTS-Modell

Sprachsynthese auf dem Gerät (Textual content-to-Speech)

Dieses Modell erzeugt Audio, das natürlich klingt. Es bedient 10 indische Sprachen sowie 8 Stimmen.

• Modellgröße: 24 Millionen Parameter.
• Geräte-Footprint: Nur ~60 MB.
• Geschwindigkeit: Auf einem Samsung Galaxy S25 Extremely beginnt es in 260 Millisekunden zu sprechen. Es generiert Audio fünfmal schneller als in Echtzeit.

Die gleiche Individual wird unabhängig von der Sprache wie ein großartiges Stimmmodell klingen. Um dies zu messen, verwendete Sarvam Sprecherähnlichkeitswerte. Je höher die Punktzahl, desto größer die Konsistenz.

Die Werte für die Ähnlichkeit sind bei jedem Sprecher hoch, wie in der Grafik dargestellt. Die Ähnlichkeit der Stimmen wird beobachtet, wenn man in derselben Sprache spricht oder wenn various Sprachen verwendet werden. Dies führt zu einem reibungslosen und natürlichen Hörprozess.

Übersetzung auf dem Gerät

Es gibt ein Übersetzungsmodell, das 11 Sprachen umfasst. Diese besteht aus 10 indischen Sprachen und Englisch. Es ist in der Lage, jedes dieser 110 Sprachpaare direkt miteinander zu übersetzen.

• Modellgröße: ~150 Millionen Parameter.
• Geräte-Footprint: ~334 MB.
• Geschwindigkeit: Das erste übersetzte Token wird in etwa 200 Millisekunden bereitgestellt. Es hat einen Durchsatz von 30 Token professional Sekunde auf einem Snapdragon 8 Gen 3 Chip.

Die Qualität der Übersetzung wurde anhand des chrF-Scores im FLORES-Benchmark bewertet. Diese Punktzahl bestimmt den Grad des Erfolgs bei der Übersetzung des Originaltextes in Bezug auf die Bedeutung.

Das Sarvam-Edge-Modell wird im Vergleich zu anderen wichtigen Modellen, wie z. B. der Erfüllung von Meta-NLLB-600M, in allen experimentellen Sprachen in Indien höher bewertet. Dies zeigt, dass es bei der Anwendung mehrsprachiger Aufgaben von hoher Qualität und Genauigkeit ist.

Sarvam Edge in Aktion

Obwohl das Sarvam Edge SDK, das direkt auf {Hardware} genutzt werden kann, noch nicht Open Supply ist, stellte das Group einige Beispiele des Methods in der Praxis bereit. Diese Demos demonstrieren die Praxistauglichkeit der Modelle in der alltäglichen {Hardware}.

1. Imaginative and prescient OCR auf dem MacBook Professional

Das erste Beispiel zeigt das Lokale Optische Zeichenerkennung (OCR) auf einem Laptop computer. Das System wandelt ein Bild, das Odia-Textual content enthält, in reinen Textual content um, wenn es vollständig offline ist. Es läuft mit einer Geschwindigkeit von mehr als 40 Token professional Sekunde. Der Spitzenspeicher überschreitet nicht 10 GB.

Diese Demonstration ist ein großer Erfolg in Sachen Barrierefreiheit. Odia ist ein komplexes Drehbuch. Es ist sehr optimiert, wenn es lokal auf einem normalen Laptop computer verwendet wird. Die Speicherkapazität von 10 GB ist angemessen. Dies bedeutet, dass das Modell mit anderen Anwendungen ausgeführt werden kann, ohne dass das System abstürzt.

2. Sprachgesteuerte Börsenvermittlung auf Android

Android verfügt über einen Finanzassistenten, der Aktienkäufe und Portfolioabfragen per Sprache verwaltet. Alle Sprache-zu-Textual content und Textual content-to-Speech-Funktionen werden vom Gerät übernommen. Auch ohne Internetverbindung können Guthaben abgefragt oder Aktien gekauft werden.

Der wichtigste Faktor ist in diesem Fall die Privatsphäre. Einzelpersonen sind normalerweise vorsichtig, wenn es darum geht, Finanzinformationen an Cloud-Repositorys zu senden. Die lokale Bearbeitung dieser Anfragen schafft Vertrauen. Darüber hinaus ist das Null-Lag-Erlebnis für schnelllebige Märkte, in denen Zeit von entscheidender Bedeutung ist, von entscheidender Bedeutung.

3. Mehrsprachige Übersetzung in Echtzeit

In dieser Demo unterhalten sich zwei Personen in verschiedenen indischen Sprachen. Ihre Rede wird in Echtzeit im System übersetzt. Es basiert auf einer Folge lokaler Modelle zur Erkennung, Übersetzung und Synthese. Der Dialog ist nicht künstlich und die ursprüngliche Bedeutung wurde beibehalten.

Dies ist ein großes Kommunikationsproblem, das in einem Land mit vielen Sprachen gelöst wird. Bei der Übersetzung sollte die Latenz nahe Null liegen, damit sie sich natürlich anfühlt. Flüssige, sprachübergreifende Gespräche können jetzt überall stattfinden, da der Cloud-Roundtrip entfällt.

Abschluss

Sarvam Edge ist eine bedeutende Veränderung in der indischen KI-Welt. Es versorgt die riesigen Cloud-Server direkt in Ihrer Tasche mit Strom. Die Benchmarks zeigen, dass lokale Modelle schnell und präzise sind. Sie verarbeiten komplizierte indische Sprachen mit geringer Latenz und hoher Geschwindigkeit. Sie müssen nie warten, bis das Finish-SDK beginnt. Derzeit können wir mithilfe gehosteter APIs versatile Anwendungen erstellen. Auf diese Weise können Sie sofort zur lokalen Verarbeitung übergehen. Das ist eine großartige strategische Positionierung. Jetzt haben Sie, was Sie jetzt wollen, und das ist absolute Privatsphäre in der Zukunft. Die KI auf dem Gerät wird außerdem dafür sorgen, dass die Technologie für alle persönlicher und zuverlässiger ist.

Häufig gestellte Fragen

Harsh Mishra ist ein KI/ML-Ingenieur, der mehr Zeit damit verbringt, mit großen Sprachmodellen zu sprechen als mit echten Menschen. Leidenschaftlich für GenAI, NLP und die intelligentere Entwicklung von Maschinen (damit sie ihn noch nicht ersetzen). Wenn er nicht gerade Modelle optimiert, optimiert er wahrscheinlich seinen Kaffeekonsum.

Bild vom Autor | Ideogram.ai

# Einführung

Beim Erstellen großer Sprachmodellanwendungen sind Token Geld. Wenn Sie jemals mit einem LLM wie GPT-4 gearbeitet haben, hatten Sie wahrscheinlich den Second, in dem Sie die Rechnung überprüften und dachten: „Wie ist es so hoch geworden?!“ Jeder von Ihnen durchgeführte API-Aufruf verbraucht Token, was sich direkt auf die Latenz und die Kosten auswirkt. Aber ohne sie zu verfolgen, haben Sie keine Ahnung, wofür sie ausgegeben werden und wie Sie sie optimieren können.

Das ist wo LangSmith kommt ins Spiel. Es verfolgt nicht nur Ihre LLM-Aufrufe, sondern ermöglicht Ihnen auch die Protokollierung, Überwachung und Visualisierung der Token-Nutzung für jeden Schritt in Ihrem Workflow. In diesem Leitfaden behandeln wir Folgendes:

1. Warum ist Token-Monitoring wichtig?
2. Wie richte ich die Protokollierung ein?
3. Wie kann der Token-Verbrauch im LangSmith-Dashboard visualisiert werden?

# Warum ist Token-Monitoring wichtig?

Die Nachverfolgung von Token ist wichtig, da jede Interaktion mit einem großen Sprachmodell direkte Kosten verursacht, die von der Anzahl der verarbeiteten Token abhängig sind, sowohl in Ihren Eingaben als auch in den Ausgaben des Modells. Ohne Überwachung können kleine Ineffizienzen bei Eingabeaufforderungen, unnötiger Kontext oder redundante Anfragen Ihre Rechnung in die Höhe treiben und die Leistung verlangsamen.

Durch die Nachverfolgung von Token erhalten Sie einen genauen Überblick darüber, wo sie verbraucht werden. Auf diese Weise können Sie Eingabeaufforderungen optimieren, Arbeitsabläufe rationalisieren und die Kostenkontrolle behalten. Wenn Ihr Chatbot beispielsweise 1.500 Token professional Anfrage verwendet, können die Kosten durch eine Reduzierung auf 800 Token quick halbiert werden. Das Token-Monitoring-Konzept funktioniert irgendwie so:

# Einrichten von LangSmith für die Token-Protokollierung

// Schritt 1: Erforderliche Pakete installieren

pip3 set up langchain langsmith transformers speed up langchain_community

// Schritt 2: Führen Sie alle erforderlichen Importe durch

import os
from transformers import pipeline
from langchain.llms import HuggingFacePipeline
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langsmith import traceable

// Schritt 3: Langsmith konfigurieren

Stellen Sie Ihre ein API-Schlüssel und Projektname:

# Exchange along with your API key
os.environ("LANGCHAIN_API_KEY") = "your-api-key"
os.environ("LANGCHAIN_PROJECT") = "HF_FLAN_T5_Base_Demo"
os.environ("LANGCHAIN_TRACING_V2") = "true"


# Non-compulsory: disable tokenizer parallelism warnings
os.environ("TOKENIZERS_PARALLELISM") = "false"

// Schritt 4: Laden Sie ein Hugging Face-Modell

Verwenden Sie ein CPU-freundliches Modell wie google/flan-t5-base und aktivieren Sie das Sampling für natürlichere Ergebnisse:

model_name = "google/flan-t5-base"
pipe = pipeline(
   "text2text-generation",
   mannequin=model_name,
   tokenizer=model_name,
   system=-1,      # CPU
   max_new_tokens=60,
   do_sample=True, # allow sampling
   temperature=0.7
)
llm = HuggingFacePipeline(pipeline=pipe)

// Schritt 5: Erstellen Sie eine Eingabeaufforderung und eine Kette

Definieren Sie eine Eingabeaufforderungsvorlage und verbinden Sie sie mithilfe von LLMChain mit Ihrer Hugging Face-Pipeline:

prompt_template = PromptTemplate.from_template(
   "Clarify gravity to a 10-year-old in about 20 phrases utilizing a enjoyable analogy."
)


chain = LLMChain(llm=llm, immediate=prompt_template)

// Schritt 6: Machen Sie die Funktion mit LangSmith rückverfolgbar

Verwenden Sie den @traceable-Dekorator, um Eingaben, Ausgaben, Token-Nutzung und Laufzeit automatisch zu protokollieren:

@traceable(identify="HF Clarify Gravity")
def explain_gravity():
   return chain.run({})

// Schritt 7: Führen Sie die Funktion aus und drucken Sie die Ergebnisse aus

reply = explain_gravity()
print("n=== Hugging Face Mannequin Reply ===")
print(reply)

Ausgabe:

=== Hugging Face Mannequin Reply ===
Gravity is a measure of mass of an object.

// Schritt 8: Überprüfen Sie das Langsmith-Dashboard

Gehe zu smith.langchain.com → Projekte verfolgen. Sie werden etwas wie:

Sie können sogar die mit jedem Projekt verbundenen Kosten sehen und so Ihre Abrechnung analysieren. Um nun die Verwendung von Tokens und andere Erkenntnisse zu sehen, klicken Sie auf Ihr Projekt. Und Sie werden sehen:

Das rote Feld hebt die Anzahl der Durchläufe hervor, die Sie für Ihr Projekt durchgeführt haben, und listet diese auf. Klicken Sie auf einen beliebigen Lauf und Sie werden Folgendes sehen:

Hier können Sie verschiedene Dinge sehen, wie z. B. die Gesamtzahl der Token, die Latenz usw. Klicken Sie wie unten gezeigt auf das Dashboard:

Jetzt können Sie Diagramme im Zeitverlauf anzeigen, um Token-Nutzungstrends zu verfolgen, die durchschnittliche Latenz professional Anfrage zu überprüfen, Eingabe- und Ausgabe-Tokens zu vergleichen und Spitzennutzungszeiten zu identifizieren. Diese Erkenntnisse helfen dabei, Eingabeaufforderungen zu optimieren, Kosten zu verwalten und die Modellleistung zu verbessern.

Bitte scrollen Sie nach unten, um alle mit Ihrem Projekt verknüpften Diagramme anzuzeigen.

// Schritt 9: Erkunden Sie das LangSmith-Dashboard

Sie können viele der Erkenntnisse analysieren, wie zum Beispiel:

• Beispielspuren anzeigen: Klicken Sie auf eine Ablaufverfolgung, um die detaillierte Ausführung anzuzeigen, einschließlich Roheingabe, generierter Ausgabe und Leistungsmetriken
• Einzelne Spuren prüfen: Für jede Ablaufverfolgung können Sie jeden Schritt der Ausführung untersuchen und Eingabeaufforderungen, Ausgaben, Token-Nutzung und Latenz anzeigen
• Überprüfen Sie die Token-Nutzung und Latenz: Detaillierte Token-Zählungen und Verarbeitungszeiten helfen dabei, Engpässe zu erkennen und die Leistung zu optimieren
• Bewertungsketten: Verwenden Sie die Evaluierungstools von LangSmith, um Szenarien zu testen, die Modellleistung zu verfolgen und Ergebnisse zu vergleichen
• Experimentieren Sie auf dem Spielplatz: Passen Sie Parameter wie Temperatur, Eingabeaufforderungsvorlagen oder Probenahmeeinstellungen an, um das Verhalten Ihres Modells zu optimieren

Mit diesem Setup haben Sie jetzt im LangSmith-Dashboard vollständige Sicht auf die Ausführungen Ihres Hugging Face-Modells, die Token-Nutzung und die Gesamtleistung.

# Wie erkennt und behebt man Token Hogs?

Sobald Sie über die Protokollierung verfügen, können Sie:

• Überprüfen Sie, ob die Eingabeaufforderungen zu lang sind
• Identifizieren Sie Aufrufe, bei denen das Modell zu viel generiert
• Wechseln Sie für günstigere Aufgaben zu kleineren Modellen
• Antworten zwischenspeichern, um doppelte Anfragen zu vermeiden

Dies ist Gold wert, um lange Ketten oder Agenten zu debuggen. Finden Sie den Schritt, der die meisten Token frisst, und beheben Sie ihn.

# Zusammenfassung

So können Sie Langsmith einrichten und nutzen. Bei der Protokollierung der Token-Nutzung geht es nicht nur darum, Geld zu sparen, sondern auch darum, intelligentere und effizientere LLM-Apps zu entwickeln. Der Leitfaden bietet eine Grundlage. Sie können mehr erfahren, indem Sie Ihre eigenen Arbeitsabläufe erkunden, experimentieren und analysieren.

Kanwal Mehreen ist ein Ingenieur für maschinelles Lernen und ein technischer Redakteur mit einer großen Leidenschaft für Datenwissenschaft und die Schnittstelle zwischen KI und Medizin. Sie ist Mitautorin des E-Books „Maximizing Productiveness with ChatGPT“. Als Google Era Scholar 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie ist außerdem als Teradata Range in Tech Scholar, Mitacs Globalink Analysis Scholar und Harvard WeCode Scholar anerkannt. Kanwal ist ein leidenschaftlicher Verfechter von Veränderungen und hat FEMCodes gegründet, um Frauen in MINT-Bereichen zu stärken.

Bild von Autor | Ideogramm

# Einführung

Ich bin sicher, dass die meisten von Ihnen irgendwann eine Befehlshabls verwendet haben. Wenn Sie es nicht getan haben, obwohl es im Vergleich zu einer GUI langweilig aussieht, ist eine Befehlszeilenschnittstelle (CLI) sehr leicht und gibt Ihnen viel mehr Kontrolle. Einige häufige Beispiele sind SQLite, Git und die Python Repl. In diesem Tutorial lernen wir, wie man Python verwendet cmd Modul zum Erstellen unserer eigenen interaktiven Shell ohne externe Abhängigkeiten. Es ist sehr einfach und intuitiv, loszulegen. Wenn Sie an solchen Projekten arbeiten, können Sie verstehen, wie die Dinge unter der Motorhaube funktionieren – Dinge, die Sie normalerweise jeden Tag verwenden, aber nicht viel darüber nachdenken. Es ist auch nützlich, wenn Sie jemals vorhaben, Administratorkonsolen für Ihre Anwendungen zu erstellen.

Wir bauen unsere Shell in kleinen Stücken, beginnend mit einem minimalen Beispiel und fügen dann allmählich Befehle, Hilfe, grundlegende Validierung, Aliase und freundliche Ausgabe hinzu. Die einzige Voraussetzung von Ihrer Seite ist die grundlegende Vertrautheit mit Python -Funktionen und -klassen. Additionally fangen wir an.

# Schritt-für-Schritt-Prozess, um Ihre eigene Python-Shell zu erstellen

Lassen Sie uns einen kurzen Überblick darüber haben cmd Modul, da wir es bereits verwendet haben, aber nicht erklärt haben, was es ist. Es bietet eine Basisklasse (cmd.Cmd) zu bauen zeilenorientierte Befehlsinterpretenwas bedeutet, dass es jeweils einen Befehl verarbeitet. Es kümmert sich auch um das Lesen der Eingaben über eine Eingabeaufforderung, den Befehlsabschnitt (Mapping -Textual content zu Methoden) und das Hilfesystem. Sie implementieren Befehle, indem Sie die benannten Methoden definieren do_<command>. Das Modul behandelt den Relaxation – einfach und einfach.

// Schritt 1: Erstellen der minimalen Schale

Erstellen Sie eine Datei aufgerufen myshell.py:

import cmd

class MyShell(cmd.Cmd):
    intro = "Welcome to MyShell! Sort assist or ? to listing instructions.n"
    immediate = "(myshell) "

    def do_greet(self, arg):
        """Greet the named particular person: greet <title>"""
        title = arg.strip() or "stranger"
        print(f"Hi there, {title}!")

    def do_exit(self, arg):
        """Exit the shell."""
        print("Goodbye!")
        return True  # Returning True tells cmdloop() to exit

if __name__ == "__main__":
    MyShell().cmdloop()

Führen Sie den Code mit: Ausführen:

Versuchen wir nun ein paar Befehle. cmdloop() Starten Sie die interaktive Schleife und wir können wie unten gezeigt interagieren:

Welcome to MyShell! Sort assist or ? to listing instructions.
(myshell) assist

Documented instructions (sort assist <matter>):
========================================
exit  greet  assist

(myshell) ?
Documented instructions (sort assist <matter>):
========================================
exit  greet  assist

(myshell) greet kanwal
Hi there, kanwal!

(myshell) exit
Goodbye!

// Schritt 2: Argumente sauber analysieren

Für komplexere Befehle, die mehrere Eingabewerte erfordern – wie beim Hinzufügen oder Multiplizieren – benötigen Sie etwas, um Räume, Zitate usw. zu analysieren. Dafür werden wir verwenden shlex.cut up. Schauen wir uns den Beispielcode an:

import cmd
import shlex

class MyShell(cmd.Cmd):
    intro = "Welcome to MyShell! Sort assist or ? to listing instructions.n"
    immediate = "(myshell) "

    def do_add(self, arg):
        """Add numbers: add 1 2 3"""
        strive:
            components = shlex.cut up(arg)
            nums = (float(p) for p in components)
        besides ValueError:
            print("Error: all arguments should be numbers.")
            return
        besides Exception as e:
            print(f"Parse error: {e}")
            return

        whole = sum(nums)
        print(f"Sum = {whole}")

    def do_exit(self, arg):
        """Exit the shell."""
        print("Goodbye!")
        return True

if __name__ == "__main__":
    MyShell().cmdloop()

Probieren wir es jetzt aus:

Welcome to MyShell! Sort assist or ? to listing instructions.

(myshell) ?
Documented instructions (sort assist <matter>):
========================================
add  exit  assist

(myshell) add 2450 3456 8904 3467 
Sum = 18277.0

(myshell) exit
Goodbye!

// Schritt 3: Hinzufügen eines Hilfesystems

Wir haben oben bereits einen Hilfebefehl gesehen. Das ist die Standardeinstellung, die die cmd Das Modul erstellt automatisch. Es zeigt die Methode Docstrings. Sie können auch benutzerdefinierte Hilfe für einen Befehl oder ein solches Thema hinzufügen:

class MyShell(cmd.Cmd):
    intro = "Welcome to MyShell! Sort assist or ? to listing instructions.n"
    immediate = "(myshell) "

    def do_greet(self, arg):
        """Greet somebody. Utilization: greet <title>"""
        title = arg.strip() or "stranger"
        print(f"Hi there, {title}!")

    def help_greet(self):
        print("greet <title>")
        print("  Prints a pleasant greeting.")
        print("  Instance: greet Alice")

    def do_exit(self, arg):
        """Exit the shell."""
        print("Goodbye!")
        return True

    def do_help(self, arg):
        # Maintain default habits, however present a tiny information when no arg
        if arg:
            return tremendous().do_help(arg)
        tremendous().do_help(arg)
        print()
        print("Fundamentals:")
        print("  - Use 'assist' or '?' to listing instructions.")
        print("  - Use 'assist <command>' for particulars.")
        print("  - Arguments help quotes (through shlex).")

Welcome to MyShell! Sort assist or ? to listing instructions.

(myshell) assist
Documented instructions (sort assist <matter>):
========================================
exit  greet
Undocumented instructions:
======================
assist
Fundamentals:
  - Use 'assist' or '?' to listing instructions.
  - Use 'assist <command>' for particulars.
  - Arguments help quotes (through shlex).
  
(myshell) assist greet
greet <title>
  Prints a pleasant greeting.
  Instance: greet Alice
  
(myshell) assist exit
Exit the shell.

(myshell) exit
Goodbye!

// Schritt 4: Handhabungsfehler und unbekannte Befehle

Wir können das überschreiben default() Methode, um unbekannte Befehle abzufangen. Sie können auch verwenden emptyline() Um zu steuern, was passiert, wenn der Benutzer ohne Eingabe eingeben. Lassen Sie uns die Shell nichts tun, wenn keine Eingabe eingegeben wurde:

class MyShell(cmd.Cmd):
    immediate = "(myshell) "

    def default(self, line):
        print(f"Unknown command: {line!r}. Sort 'assist' to listing instructions.")

    def emptyline(self):
        # By default, urgent Enter repeats the final command. Override to do nothing.
        go

    def do_exit(self, arg):
        """Exit the shell."""
        print("Goodbye!")
        return True

(myshell) assist

Documented instructions (sort assist <matter>):
========================================
exit  assist

(myshell) 
(myshell) 
(myshell) exit
Goodbye!

// Schritt 5: Hinzufügen von Befehls -Aliase

Aliase sind kurze Namen. Tonnen meiner Freunde haben auch Aliase, insbesondere diejenigen mit den gleichen Namen. In ähnlicher Weise können Sie eine kürzere – und leichter zu erinnern zu erinnern zu erinnern precmd() Verfahren. So können Sie das tun:

import shlex
import cmd

class MyShell(cmd.Cmd):
    immediate = "(myshell) "
    aliases = {
        "give up": "exit",
        "q": "exit",
        "whats up": "greet",
        "sum": "add",
    }

    def precmd(self, line: str) -> str:
        # Normalize/therapeutic massage enter earlier than dispatch
        components = line.strip().cut up(maxsplit=1)
        if not components:
            return line
        cmd_name = components(0)
        relaxation = components(1) if len(components) > 1 else ""
        if cmd_name in self.aliases:
            cmd_name = self.aliases(cmd_name)
        return f"{cmd_name} {relaxation}".strip()

    # Outline instructions used above
    def do_greet(self, arg):
        """Greet somebody. Utilization: greet <title>"""
        title = arg.strip() or "stranger"
        print(f"Hi there, {title}!")

    def do_add(self, arg):
        """Add numbers: add 1 2 3"""
        strive:
            nums = (float(x) for x in shlex.cut up(arg))
        besides Exception:
            print("Utilization: add <num> (<num> ...)")
            return
        print(f"Sum = {sum(nums)}")

    def do_exit(self, arg):
        """Exit the shell."""
        print("Goodbye!")
        return True

(myshell) ?
Documented instructions (sort assist <matter>):
========================================
add  exit  greet  assist

(myshell) sum 2 3 4
Sum = 9.0

(myshell) add 2 3 4
Sum = 9.0

(myshell) q
Goodbye!

// Schritt 6: alles zusammenfügen

import cmd
import shlex

class MyShell(cmd.Cmd):
    intro = "Welcome to MyShell! Sort assist or ? to listing instructions."
    immediate = "(myshell) "

    # Easy aliases
    aliases = {"q": "exit", "give up": "exit", "whats up": "greet", "sum": "add"}

    # ----- Enter processing -----
    def precmd(self, line):
        components = line.strip().cut up(maxsplit=1)
        if not components:
            return line
        cmd_name = components(0)
        relaxation = components(1) if len(components) > 1 else ""
        if cmd_name in self.aliases:
            cmd_name = self.aliases(cmd_name)
        return f"{cmd_name} {relaxation}".strip()

    def emptyline(self):
        # Do nothing on empty line
        go

    def default(self, line):
        print(f"Unknown command: {line!r}. Sort 'assist' to listing instructions.")

    # ----- Instructions -----
    def do_greet(self, arg):
        """Greet somebody. Utilization: greet <title>"""
        title = arg.strip() or "stranger"
        print(f"Hi there, {title}!")

    def help_greet(self):
        print("greet <title>")
        print("  Prints a pleasant greeting.")
        print("  Instance: greet Alice")

    def do_add(self, arg):
        """Add numbers: add 1 2 3"""
        strive:
            nums = (float(x) for x in shlex.cut up(arg))
        besides Exception:
            print("Utilization: add <num> (<num> ...)")
            return
        print(f"Sum = {sum(nums)}")

    def do_echo(self, arg):
        """Echo again what you sort: echo <textual content>"""
        print(arg)

    def do_exit(self, arg):
        """Exit the shell."""
        print("Goodbye!")
        return True

    # ----- Assist tweaks -----
    def do_help(self, arg):
        if arg:
            return tremendous().do_help(arg)
        tremendous().do_help(arg)
        print()
        print("Fundamentals:")
        print("  - Use 'assist' or '?' to listing instructions.")
        print("  - Use 'assist <command>' for particulars.")
        print('  - Quotes are supported in arguments (e.g., add "3.5" 2).')

if __name__ == "__main__":
    MyShell().cmdloop()

Welcome to MyShell! Sort assist or ? to listing instructions.
(myshell) whats up
Hi there, stranger!
(myshell) WRONG COMMAND
Unknown command: 'WRONG COMMAND'. Sort 'assist' to listing instructions.
(myshell) echo KDnuggets is a good website
KDnuggets is a good website
(myshell) exit
Goodbye!

# Einpacken

Sie haben gerade gelernt, wie man eine interaktive Hülle mit dem baut cmd Modul ohne externe Abhängigkeiten. Ist das nicht erstaunlich?

Bevor wir fertig sind, lohnt es sich, darauf hinzuweisen ein paar häufige Fallstricke Zu achten auf: Erstens vergessen, zurückzukehren True In Ihrem Ausgangsbefehl verhindern die Shell -Schleife. Zweitens kann es zu Problemen führen, wenn Benutzer auf einfache Whitespace -Aufteilung für Argumente zu Problemen führen, wenn Benutzer den zitierten Textual content eingeben. shlex wird empfohlen. Schließlich nicht mit dem umzugehen emptyline() Methode kann ordnungsgemäß zu unerwartetem Verhalten führen, z. B. das Wiederholen des letzten Befehls, wenn der Benutzer in eine leere Zeile eingegeben wird.

Ich würde gerne Ihre Gedanken zu diesem Artikel im Kommentarbereich sowie alle Ideen hören, die Sie möglicherweise weiter untersuchen möchten.

Kanwal Mehreen ist ein Ingenieur für maschinelles Lernen und technischer Schriftsteller mit einer tiefgreifenden Leidenschaft für die Datenwissenschaft und die Schnittstelle von KI mit Medizin. Sie hat das eBook „Produktivität mit Chatgpt maximieren“. Als Google -Technology -Gelehrte 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie wird auch als Teradata -Vielfalt in Tech Scholar, MITACS Globalink Analysis Scholar und Harvard Wecode Scholar anerkannt. Kanwal ist ein leidenschaftlicher Verfechter der Veränderung, nachdem er Femcodes gegründet hat, um Frauen in STEM -Bereichen zu stärken.

Bild von Autor | Leinwand

# Einführung

Die Open-Supply-KI erlebt einen bedeutenden Second. Mit Fortschritten in Großsprachenmodellen, allgemeinem maschinellem Lernen und jetzt Sprachtechnologien verengen Open-Supply-Modelle die Lücke zu proprietären Systemen schnell. Einer der aufregendsten Teilnehmer in diesem Bereich ist der Open-Supply-Sprachstack von Microsoft Vibevoice. Diese Modellfamilie ist für natürliche, ausdrucksstarke und interaktive Konversation konzipiert und mit der Qualität der hochwertigen kommerziellen Angebote mithalten.

In diesem Artikel werden wir Vibevoice untersuchen, das Modell herunterladen und mithilfe der GPU -Laufzeit die Inferenz auf Google Colab ausführen. Darüber hinaus werden wir die Fehlerbehebung mit allgemeinen Problemen befassen, die bei der Ausführung von Modellinferenz auftreten können.

# Einführung in Vibevoice

Vibevoice ist ein TTS-Framework (Textual content-to-Speech) der nächsten Era zum Erstellen von Ausdrucks-, Langform-, Multi-Speaker-Audio wie Podcasts und Dialogen. Im Gegensatz zu herkömmlichen TTs übertrifft es sich in Skalierbarkeit, Sprecherkonsistenz und natürlicher Wende.

Seine Kerninnovation liegt in kontinuierlichen akustischen und semantischen Tokenisierern, die bei 7,5 Hz arbeiten, mit einem großen Sprachmodell (QWEN2.5-1.5B) und einem Diffusionskopf zur Erzeugung von Audio mit hohem Constancy. Dieses Design ermöglicht bis zu 90 Minuten Sprache mit 4 verschiedenen Lautsprechern, die frühere Systeme übertreffen.

Vibevoice ist als Open-Supply-Modell erhältlich Umarmtes Gesichtmit in der Gemeinschaft gepflegter Code für einfache Experimente und Verwendung.

Bild von Vibevoice

# Erste Schritte mit Vibevoice-1.5b

In diesem Leitfaden lernen wir, wie Sie das Vibevoice-Repository klonen und die Demo ausführen, indem wir es mit einer Textdatei zur Verfügung stellen, um eine natürliche Sprache mit mehreren Sprechern zu generieren. Es dauert nur etwa 5 Minuten vom Setup bis zum Generieren des Audios.

// 1. Klonen Sie das Neighborhood -Repository und installieren Sie

Klonen Sie zunächst die Neighborhood -Model des Vibevoice -Repositorys (Vibevoice-Neighborhood/Vibevoice), installieren Sie die erforderlichen Python -Pakete und installieren Sie auch die Umarmung des Gesichtszentrums Bibliothek zum Herunterladen des Modells mit der Python -API.

Notiz: Stellen Sie vor dem Begin der Colab -Sitzung sicher, dass Ihr Laufzeittyp auf T4 GPU eingestellt ist.

!git clone -q --depth 1 https://github.com/vibevoice-community/VibeVoice.git /content material/VibeVoice
%pip set up -q -e /content material/VibeVoice
%pip set up -q -U huggingface_hub

// 2. Laden Sie den Modell -Schnappschuss vom Umarmungsgesicht herunter

Laden Sie das Modellrepository mit der API des Umarmungsgesichts -Snapshots herunter. Dadurch wird alle Dateien von der heruntergeladen microsoft/VibeVoice-1.5B Repository.

from huggingface_hub import snapshot_download
snapshot_download(
    "microsoft/VibeVoice-1.5B",
    local_dir="/content material/fashions/VibeVoice-1.5B",
    local_dir_use_symlinks=False
)

// 3. Erstellen Sie ein Transkript mit Sprechern

Wir erstellen eine Textdatei in Google Colab. Dafür werden wir die magische Funktion verwenden %%writefile Inhalt bereitstellen. Im Folgenden finden Sie ein Beispielgespräch zwischen zwei Rednern über KDNuggets.

%%writefile /content material/my_transcript.txt
Speaker 1: Have you ever learn the most recent article on KDnuggets?
Speaker 2: Sure, it is among the finest assets for information science and AI.
Speaker 1: I like how KDnuggets all the time retains up with the most recent traits.
Speaker 2: Completely, it is a go-to platform for anybody within the AI neighborhood.

// 4. Inferenz rennen (Mehrfachleiter)

Jetzt werden wir das Demo Python -Skript im Vibevoice -Repository ausführen. Das Skript erfordert den Modellpfad, den Textdateipfad und den Sprechernamen.

Lauf Nr. 1: Kartenlautsprecher 1 → Alice, Lautsprecher 2 → Frank

!python /content material/VibeVoice/demo/inference_from_file.py 
  --model_path /content material/fashions/VibeVoice-1.5B 
  --txt_path /content material/my_transcript.txt 
  --speaker_names Alice Frank

Infolgedessen sehen Sie die folgende Ausgabe. Das Modell wird CUDA verwenden, um das Audio mit Frank und Alice als beiden Lautsprechern zu generieren. Es bietet auch eine Zusammenfassung, die Sie zur Analyse verwenden können.

Utilizing system: cuda
Discovered 9 voice information in /content material/VibeVoice/demo/voices
Out there voices: en-Alice_woman, en-Carter_man, en-Frank_man, en-Mary_woman_bgm, en-Maya_woman, in-Samuel_man, zh-Anchen_man_bgm, zh-Bowen_man, zh-Xinran_woman
Studying script from: /content material/my_transcript.txt
Discovered 4 speaker segments:
  1. Speaker 1
     Textual content preview: Speaker 1: Have you ever learn the most recent article on KDnuggets?...
  2. Speaker 2
     Textual content preview: Speaker 2: Sure, it is among the finest assets for information science and AI....
  3. Speaker 1
     Textual content preview: Speaker 1: I like how KDnuggets all the time retains up with the most recent traits....
  4. Speaker 2
     Textual content preview: Speaker 2: Completely, it is a go-to platform for anybody within the AI neighborhood....

Speaker mapping:
  Speaker 2 -> Frank
  Speaker 1 -> Alice
Speaker 1 ('Alice') -> Voice: en-Alice_woman.wav
Speaker 2 ('Frank') -> Voice: en-Frank_man.wav
Loading processor & mannequin from /content material/fashions/VibeVoice-1.5B
==================================================
GENERATION SUMMARY
==================================================
Enter file: /content material/my_transcript.txt
Output file: ./outputs/my_transcript_generated.wav
Speaker names: ('Alice', 'Frank')
Variety of distinctive audio system: 2
Variety of segments: 4
Prefilling tokens: 368
Generated tokens: 118
Whole tokens: 486
Era time: 28.27 seconds
Audio length: 15.47 seconds
RTF (Actual Time Issue): 1.83x
==================================================

Spielen Sie das Audio in Pocket book:

Wir werden nun die Ipython -Funktion verwenden, um das generierte Audio in Colab anzuhören.

from IPython.show import Audio, show
out_path = "/content material/outputs/my_transcript_generated.wav"
show(Audio(out_path))

Es dauerte 28 Sekunden, um das Audio zu erzeugen, und es klingt klar, natürlich und glatt. Ich liebe es!

Versuchen Sie es erneut mit verschiedenen Sprachakteuren.

Lauf Nr. 2: Probieren Sie verschiedene Stimmen aus (Mary für Sprecher 1, Carter für Sprecher 2)

!python /content material/VibeVoice/demo/inference_from_file.py 
  --model_path /content material/fashions/VibeVoice-1.5B 
  --txt_path /content material/my_transcript.txt 
  --speaker_names Mary Carter

Das generierte Audio conflict noch besser, mit Hintergrundmusik am Anfang und einem reibungslosen Übergang zwischen den Lautsprechern.

Discovered 9 voice information in /content material/VibeVoice/demo/voices
Out there voices: en-Alice_woman, en-Carter_man, en-Frank_man, en-Mary_woman_bgm, en-Maya_woman, in-Samuel_man, zh-Anchen_man_bgm, zh-Bowen_man, zh-Xinran_woman
Studying script from: /content material/my_transcript.txt
Discovered 4 speaker segments:
  1. Speaker 1
     Textual content preview: Speaker 1: Have you ever learn the most recent article on KDnuggets?...
  2. Speaker 2
     Textual content preview: Speaker 2: Sure, it is among the finest assets for information science and AI....
  3. Speaker 1
     Textual content preview: Speaker 1: I like how KDnuggets all the time retains up with the most recent traits....
  4. Speaker 2
     Textual content preview: Speaker 2: Completely, it is a go-to platform for anybody within the AI neighborhood....

Speaker mapping:
  Speaker 2 -> Carter
  Speaker 1 -> Mary
Speaker 1 ('Mary') -> Voice: en-Mary_woman_bgm.wav
Speaker 2 ('Carter') -> Voice: en-Carter_man.wav
Loading processor & mannequin from /content material/fashions/VibeVoice-1.5B

Tipp: Wenn Sie sich nicht sicher sind, welche Namen verfügbar sind, druckt das Skript „verfügbare Stimmen:“ beim Begin.

Zu den allgemeinen gehören:

en-Alice_woman, en-Carter_man, en-Frank_man, en-Mary_woman_bgm, en-Maya_woman, in-Samuel_man, zh-Anchen_man_bgm, zh-Bowen_man, zh-Xinran_woman

# Fehlerbehebung

// 1. Repo hat keine Demo -Skripte?

Das offizielle Microsoft Vibevoice -Repository wurde gezogen und zurückgesetzt. Neighborhood -Berichte zeigen, dass Code und Demos entfernt wurden oder am ursprünglichen Ort nicht mehr zugänglich sind. Wenn Sie feststellen, dass das offizielle Repository Beispiele fehlen, überprüfen Sie bitte einen Neighborhood -Spiegel oder ein Archiv, das die ursprünglichen Demos und Anweisungen erhalten hat: https://github.com/vibevoice-community/vibevoice

// 2. Langsamer Era oder CUDA -Fehler in Colab

Überprüfen Sie, ob Sie sich in einer GPU -Laufzeit befinden: Laufzeit → Laufzeittyp → {Hardware} Accelerator: GPU (T4 oder eine beliebige GPU).

// 3.. CUDA OOM (aus dem Gedächtnis)

Um die Final zu minimieren, können Sie mehrere Schritte unternehmen. Beginnen Sie zunächst den Eingabetxt abkürzen und die Erzeugungslänge reduzieren. Erwägen Sie, die Audio -Stichprobenrate zu senken und/oder die internen Chunk -Größen anzupassen, wenn das Skript dies zulässt. Stellen Sie die Chargengröße auf 1 ein und wählen Sie eine kleinere Modellvariante.

// V.

Das Skript druckt normalerweise den endgültigen Ausgabepfad in der Konsole. Scrollen Sie nach oben, um den genauen Ort zu finden

discover /content material -name "*generated.wav"

// 5. Sprachnamen nicht gefunden?

Kopieren Sie die genauen Namen, die unter verfügbaren Stimmen aufgeführt sind. Verwenden Sie die alias -Namen (Alice, Frank, Mary, Carter), die in der Demo gezeigt sind. Sie entsprechen dem .wav Vermögenswerte.

# Letzte Gedanken

Für viele Projekte würde ich aus mehreren überzeugenden Gründen einen Open-Supply-Stapel wie Vibevoice gegenüber bezahlten APIs wählen. In erster Linie ist es einfach zu integrieren und bietet Flexibilität für die Anpassung, sodass es für eine Vielzahl von Anwendungen geeignet ist. Darüber hinaus ist es überraschend Licht in den GPU-Anforderungen, was in ressourcenbeschränkten Umgebungen von erheblichem Vorteil sein kann.

Vibevoice ist Open Supply, was bedeutet, dass Sie in Zukunft bessere Frameworks erwarten können, die auch bei CPUs eine schnellere Erzeugung ermöglichen.

Abid Ali Awan (@1abidaliawan) ist ein zertifizierter Datenwissenschaftler, der es liebt, maschinelles Lernenmodelle zu bauen. Derzeit konzentriert er sich auf die Erstellung von Inhalten und das Schreiben von technischen Blogs über maschinelles Lernen und Datenwissenschaftstechnologien. Abid hat einen Grasp -Abschluss in Technologiemanagement und einen Bachelor -Abschluss in Telekommunikationstechnik. Seine Imaginative and prescient ist es, ein KI -Produkt zu bauen, das ein Diagramm neuronales Netzwerk für Schüler mit psychische Erkrankungen mit kämpfender Krankheiten unterhält.

Bild von Autor | Ideogramm

# Einführung

Wenn Sie neu in der Analyse mit Python sind, Pandas ist normalerweise das, was die meisten Analysten lernen und verwenden. Aber Polare ist tremendous beliebt geworden und ist schneller und effizienter.

Der integrierte Rost erledigt die Datenverarbeitungsaufgaben, die andere Werkzeuge verlangsamen würden. Es ist für Geschwindigkeit, Speichereffizienz und Benutzerfreundlichkeit ausgelegt. In diesem anfängerfreundlichen Artikel werden wir fiktive Café-Store-Daten ausdrehen und sie analysieren, um Polare zu lernen. Klingt interessant? Beginnen wir!

Hyperlink zum Code auf GitHub

# Polare installieren

Bevor wir in die Analyse von Daten eintauchen, lassen Sie uns die Installationsschritte aus dem Weg räumen. Installieren Sie zuerst Polare:

! pip set up polars numpy

Importieren wir nun die Bibliotheken und Module:

import polars as pl
import numpy as np
from datetime import datetime, timedelta

Wir verwenden pl Als Alias ​​für Polare.

# Erstellen von Beispieldaten

Stellen Sie sich vor, Sie verwalten ein kleines Café, sagen Sie „Bohne dort“ und haben Hunderte von Quittungen und verwandten Daten zur Analyse. Sie möchten verstehen, welche Getränke am besten verkaufen, welche Tage die meisten Einnahmen und verwandte Fragen einbringen. Additionally ja, lass uns anfangen zu codieren!

Um diesen Leitfaden praktisch zu machen, erstellen wir einen realistischen Datensatz für „Bean to Café“. Wir werden Daten generieren, die ein Kleinunternehmer erkennen würde:

# Arrange for constant outcomes
np.random.seed(42)

# Create lifelike espresso store information
def generate_coffee_data():
    n_records = 2000
    # Espresso menu objects with lifelike costs
    menu_items = ('Espresso', 'Cappuccino', 'Latte', 'Americano', 'Mocha', 'Chilly Brew')
    costs = (2.50, 4.00, 4.50, 3.00, 5.00, 3.50)
    price_map = dict(zip(menu_items, costs))

    # Generate dates over 6 months
    start_date = datetime(2023, 6, 1)
    dates = (start_date + timedelta(days=np.random.randint(0, 180))
             for _ in vary(n_records))

    # Randomly choose drinks, then map the right value for every chosen drink
    drinks = np.random.alternative(menu_items, n_records)
    prices_chosen = (price_map(d) for d in drinks)

    information = {
        'date': dates,
        'drink': drinks,
        'value': prices_chosen,
        'amount': np.random.alternative((1, 1, 1, 2, 2, 3), n_records),
        'customer_type': np.random.alternative(('Common', 'New', 'Vacationer'),
                                          n_records, p=(0.5, 0.3, 0.2)),
        'payment_method': np.random.alternative(('Card', 'Money', 'Cell'),
                                           n_records, p=(0.6, 0.2, 0.2)),
        'score': np.random.alternative((2, 3, 4, 5), n_records, p=(0.1, 0.4, 0.4, 0.1))
    }
    return information

# Create our espresso store DataFrame
coffee_data = generate_coffee_data()
df = pl.DataFrame(coffee_data)

Dadurch wird ein Beispieldatensatz mit 2.000 Kaffee -Transaktionen erstellt. Jede Reihe repräsentiert einen Verkauf mit Particulars wie das, was bestellt wurde, wann, wie viel sie gekostet hat und wer es gekauft hat.

# Betrachten Sie Ihre Daten

Bevor Sie Daten analysieren, müssen Sie verstehen, womit Sie arbeiten. Stellen Sie sich das so vor, als würde man sich ein neues Rezept ansehen, bevor Sie mit dem Kochen beginnen:

# Take a peek at your information
print("First 5 transactions:")
print(df.head())

print("nWhat varieties of information do we now have?")
print(df.schema)

print("nHow massive is our dataset?")
print(f"We've {df.peak} transactions and {df.width} columns")

Der head() Die Methode zeigt die ersten Zeilen. Das Schema zeigt an, welche Artwork von Informationen jede Spalte enthält (Zahlen, Textual content, Daten usw.).

First 5 transactions:
form: (5, 7)
┌─────────────────────┬────────────┬───────┬──────────┬───────────────┬────────────────┬────────┐
│ date                ┆ drink      ┆ value ┆ amount ┆ customer_type ┆ payment_method ┆ score │
│ ---                 ┆ ---        ┆ ---   ┆ ---      ┆ ---           ┆ ---            ┆ ---    │
│ datetime(μs)        ┆ str        ┆ f64   ┆ i64      ┆ str           ┆ str            ┆ i64    │
╞═════════════════════╪════════════╪═══════╪══════════╪═══════════════╪════════════════╪════════╡
│ 2023-09-11 00:00:00 ┆ Chilly Brew  ┆ 5.0   ┆ 1        ┆ New           ┆ Money           ┆ 4      │
│ 2023-11-27 00:00:00 ┆ Cappuccino ┆ 4.5   ┆ 1        ┆ New           ┆ Card           ┆ 4      │
│ 2023-09-01 00:00:00 ┆ Espresso   ┆ 4.5   ┆ 1        ┆ Common       ┆ Card           ┆ 3      │
│ 2023-06-15 00:00:00 ┆ Cappuccino ┆ 5.0   ┆ 1        ┆ New           ┆ Card           ┆ 4      │
│ 2023-09-15 00:00:00 ┆ Mocha      ┆ 5.0   ┆ 2        ┆ Common       ┆ Card           ┆ 3      │
└─────────────────────┴────────────┴───────┴──────────┴───────────────┴────────────────┴────────┘

What varieties of information do we now have?
Schema({'date': Datetime(time_unit="us", time_zone=None), 'drink': String, 'value': Float64, 'amount': Int64, 'customer_type': String, 'payment_method': String, 'score': Int64})

How massive is our dataset?
We've 2000 transactions and seven columns

# Hinzufügen neuer Spalten

Lassen Sie uns nun anfangen, geschäftliche Erkenntnisse zu extrahieren. Jeder Besitzer des Coffeeshops möchte seinen Gesamtumsatz professional Transaktion kennen:

# Calculate whole gross sales quantity and add helpful date info
df_enhanced = df.with_columns((
    # Calculate income per transaction
    (pl.col('value') * pl.col('amount')).alias('total_sale'),

    # Extract helpful date elements
    pl.col('date').dt.weekday().alias('day_of_week'),
    pl.col('date').dt.month().alias('month'),
    pl.col('date').dt.hour().alias('hour_of_day')
))

print("Pattern of enhanced information:")
print(df_enhanced.head())

Ausgabe (Ihre genauen Zahlen können variieren):

Pattern of enhanced information:
form: (5, 11)
┌─────────────┬────────────┬───────┬──────────┬───┬────────────┬─────────────┬───────┬─────────────┐
│ date        ┆ drink      ┆ value ┆ amount ┆ … ┆ total_sale ┆ day_of_week ┆ month ┆ hour_of_day │
│ ---         ┆ ---        ┆ ---   ┆ ---      ┆   ┆ ---        ┆ ---         ┆ ---   ┆ ---         │
│ datetime(μs ┆ str        ┆ f64   ┆ i64      ┆   ┆ f64        ┆ i8          ┆ i8    ┆ i8          │
│ )           ┆            ┆       ┆          ┆   ┆            ┆             ┆       ┆             │
╞═════════════╪════════════╪═══════╪══════════╪═══╪════════════╪═════════════╪═══════╪═════════════╡
│ 2023-09-11  ┆ Chilly Brew  ┆ 5.0   ┆ 1        ┆ … ┆ 5.0        ┆ 1           ┆ 9     ┆ 0           │
│ 00:00:00    ┆            ┆       ┆          ┆   ┆            ┆             ┆       ┆             │
│ 2023-11-27  ┆ Cappuccino ┆ 4.5   ┆ 1        ┆ … ┆ 4.5        ┆ 1           ┆ 11    ┆ 0           │
│ 00:00:00    ┆            ┆       ┆          ┆   ┆            ┆             ┆       ┆             │
│ 2023-09-01  ┆ Espresso   ┆ 4.5   ┆ 1        ┆ … ┆ 4.5        ┆ 5           ┆ 9     ┆ 0           │
│ 00:00:00    ┆            ┆       ┆          ┆   ┆            ┆             ┆       ┆             │
│ 2023-06-15  ┆ Cappuccino ┆ 5.0   ┆ 1        ┆ … ┆ 5.0        ┆ 4           ┆ 6     ┆ 0           │
│ 00:00:00    ┆            ┆       ┆          ┆   ┆            ┆             ┆       ┆             │
│ 2023-09-15  ┆ Mocha      ┆ 5.0   ┆ 2        ┆ … ┆ 10.0       ┆ 5           ┆ 9     ┆ 0           │
│ 00:00:00    ┆            ┆       ┆          ┆   ┆            ┆             ┆       ┆             │
└─────────────┴────────────┴───────┴──────────┴───┴────────────┴─────────────┴───────┴─────────────┘

Hier ist, was passiert:

• with_columns() Fügt unseren Daten neue Spalten hinzu
• pl.col() bezieht sich auf vorhandene Spalten
• alias() Gibt unsere neuen Spalten beschreibenden Namen
• Der dt Accessor extrahiert Teile aus Daten (z. B. nur den Monat von einem vollständigen Datum erhalten)

Stellen Sie sich dies an, als würde man kalkulierte Felder zu einer Tabelle hinzufügen. Wir ändern nicht die Originaldaten und fügen nur weitere Informationen hinzu, mit denen wir arbeiten können.

# Gruppierungsdaten

Beantworten wir jetzt einige interessante Fragen.

// Frage 1: Welche Getränke sind unsere Bestseller?

Diese Code gruppiert alle Transaktionen nach Getränkentyp und berechnet dann die Summen und Durchschnittswerte für jede Gruppe. Es ist so, als würde man alle Quittungen nach Getränkentyp in Stapel sortieren und dann die Summen für jeden Stapel berechnen.

drink_performance = (df_enhanced
    .group_by('drink')
    .agg((
        pl.col('total_sale').sum().alias('total_revenue'),
        pl.col('amount').sum().alias('total_sold'),
        pl.col('score').imply().alias('avg_rating')
    ))
    .type('total_revenue', descending=True)
)

print("Drink efficiency rating:")
print(drink_performance)

Ausgabe:

Drink efficiency rating:
form: (6, 4)
┌────────────┬───────────────┬────────────┬────────────┐
│ drink      ┆ total_revenue ┆ total_sold ┆ avg_rating │
│ ---        ┆ ---           ┆ ---        ┆ ---        │
│ str        ┆ f64           ┆ i64        ┆ f64        │
╞════════════╪═══════════════╪════════════╪════════════╡
│ Americano  ┆ 2242.0        ┆ 595        ┆ 3.476454   │
│ Mocha      ┆ 2204.0        ┆ 591        ┆ 3.492711   │
│ Espresso   ┆ 2119.5        ┆ 570        ┆ 3.514793   │
│ Chilly Brew  ┆ 2035.5        ┆ 556        ┆ 3.475758   │
│ Cappuccino ┆ 1962.5        ┆ 521        ┆ 3.541139   │
│ Latte      ┆ 1949.5        ┆ 514        ┆ 3.528846   │
└────────────┴───────────────┴────────────┴────────────┘

// Frage 2: Wie sehen die täglichen Verkäufe aus?

Lassen Sie uns nun die Anzahl der Transaktionen und die entsprechenden Einnahmen für jeden Wochentag finden.

daily_patterns = (df_enhanced
    .group_by('day_of_week')
    .agg((
        pl.col('total_sale').sum().alias('daily_revenue'),
        pl.len().alias('number_of_transactions')
    ))
    .type('day_of_week')
)

print("Day by day enterprise patterns:")
print(daily_patterns)

Ausgabe:

Day by day enterprise patterns:
form: (7, 3)
┌─────────────┬───────────────┬────────────────────────┐
│ day_of_week ┆ daily_revenue ┆ number_of_transactions │
│ ---         ┆ ---           ┆ ---                    │
│ i8          ┆ f64           ┆ u32                    │
╞═════════════╪═══════════════╪════════════════════════╡
│ 1           ┆ 2061.0        ┆ 324                    │
│ 2           ┆ 1761.0        ┆ 276                    │
│ 3           ┆ 1710.0        ┆ 278                    │
│ 4           ┆ 1784.0        ┆ 288                    │
│ 5           ┆ 1651.5        ┆ 265                    │
│ 6           ┆ 1596.0        ┆ 259                    │
│ 7           ┆ 1949.5        ┆ 310                    │
└─────────────┴───────────────┴────────────────────────┘

# Filterdaten

Finden wir unsere hochwertigen Transaktionen:

# Discover transactions over $10 (a number of objects or costly drinks)
big_orders = (df_enhanced
    .filter(pl.col('total_sale') > 10.0)
    .type('total_sale', descending=True)
)

print(f"We've {big_orders.peak} orders over $10")
print("High 5 largest orders:")
print(big_orders.head())

Ausgabe:

We've 204 orders over $10
High 5 largest orders:
form: (5, 11)
┌─────────────┬────────────┬───────┬──────────┬───┬────────────┬─────────────┬───────┬─────────────┐
│ date        ┆ drink      ┆ value ┆ amount ┆ … ┆ total_sale ┆ day_of_week ┆ month ┆ hour_of_day │
│ ---         ┆ ---        ┆ ---   ┆ ---      ┆   ┆ ---        ┆ ---         ┆ ---   ┆ ---         │
│ datetime(μs ┆ str        ┆ f64   ┆ i64      ┆   ┆ f64        ┆ i8          ┆ i8    ┆ i8          │
│ )           ┆            ┆       ┆          ┆   ┆            ┆             ┆       ┆             │
╞═════════════╪════════════╪═══════╪══════════╪═══╪════════════╪═════════════╪═══════╪═════════════╡
│ 2023-07-21  ┆ Cappuccino ┆ 5.0   ┆ 3        ┆ … ┆ 15.0       ┆ 5           ┆ 7     ┆ 0           │
│ 00:00:00    ┆            ┆       ┆          ┆   ┆            ┆             ┆       ┆             │
│ 2023-08-02  ┆ Latte      ┆ 5.0   ┆ 3        ┆ … ┆ 15.0       ┆ 3           ┆ 8     ┆ 0           │
│ 00:00:00    ┆            ┆       ┆          ┆   ┆            ┆             ┆       ┆             │
│ 2023-07-21  ┆ Cappuccino ┆ 5.0   ┆ 3        ┆ … ┆ 15.0       ┆ 5           ┆ 7     ┆ 0           │
│ 00:00:00    ┆            ┆       ┆          ┆   ┆            ┆             ┆       ┆             │
│ 2023-10-08  ┆ Cappuccino ┆ 5.0   ┆ 3        ┆ … ┆ 15.0       ┆ 7           ┆ 10    ┆ 0           │
│ 00:00:00    ┆            ┆       ┆          ┆   ┆            ┆             ┆       ┆             │
│ 2023-09-07  ┆ Latte      ┆ 5.0   ┆ 3        ┆ … ┆ 15.0       ┆ 4           ┆ 9     ┆ 0           │
│ 00:00:00    ┆            ┆       ┆          ┆   ┆            ┆             ┆       ┆             │
└─────────────┴────────────┴───────┴──────────┴───┴────────────┴─────────────┴───────┴─────────────┘

# Kundenverhalten analysieren

Schauen wir uns Kundenmuster an:

# Analyze buyer conduct by sort
customer_analysis = (df_enhanced
    .group_by('customer_type')
    .agg((
        pl.col('total_sale').imply().alias('avg_spending'),
        pl.col('total_sale').sum().alias('total_revenue'),
        pl.len().alias('visit_count'),
        pl.col('score').imply().alias('avg_satisfaction')
    ))
    .with_columns((
        # Calculate income per go to
        (pl.col('total_revenue') / pl.col('visit_count')).alias('revenue_per_visit')
    ))
)

print("Buyer conduct evaluation:")
print(customer_analysis)

Ausgabe:

Buyer conduct evaluation:
form: (3, 6)
┌───────────────┬──────────────┬───────────────┬─────────────┬──────────────────┬──────────────────┐
│ customer_type ┆ avg_spending ┆ total_revenue ┆ visit_count ┆ avg_satisfaction ┆ revenue_per_visi │
│ ---           ┆ ---          ┆ ---           ┆ ---         ┆ ---              ┆ t                │
│ str           ┆ f64          ┆ f64           ┆ u32         ┆ f64              ┆ ---              │
│               ┆              ┆               ┆             ┆                  ┆ f64              │
╞═══════════════╪══════════════╪═══════════════╪═════════════╪══════════════════╪══════════════════╡
│ Common       ┆ 6.277832     ┆ 6428.5        ┆ 1024        ┆ 3.499023         ┆ 6.277832         │
│ Vacationer       ┆ 6.185185     ┆ 2505.0        ┆ 405         ┆ 3.518519         ┆ 6.185185         │
│ New           ┆ 6.268827     ┆ 3579.5        ┆ 571         ┆ 3.502627         ┆ 6.268827         │
└───────────────┴──────────────┴───────────────┴─────────────┴──────────────────┴──────────────────┘

# Alles zusammenstellen

Lassen Sie uns eine umfassende Geschäftsübersicht erstellen:

# Create a whole enterprise abstract
business_summary = {
    'total_revenue': df_enhanced('total_sale').sum(),
    'total_transactions': df_enhanced.peak,
    'average_transaction': df_enhanced('total_sale').imply(),
    'best_selling_drink': drink_performance.row(0)(0),  # First row, first column
    'customer_satisfaction': df_enhanced('score').imply()
}

print("n=== BEAN THERE COFFEE SHOP - SUMMARY ===")
for key, worth in business_summary.objects():
    if isinstance(worth, float) and key != 'customer_satisfaction':
        print(f"{key.change('_', ' ').title()}: ${worth:.2f}")
    else:
        print(f"{key.change('_', ' ').title()}: {worth}")

Ausgabe:

=== BEAN THERE COFFEE SHOP - SUMMARY ===
Whole Income: $12513.00
Whole Transactions: 2000
Common Transaction: $6.26
Greatest Promoting Drink: Americano
Buyer Satisfaction: 3.504

# Abschluss

Sie haben gerade eine umfassende Einführung in die Datenanalyse mit Polaren abgeschlossen! Mit unserem Café -Beispiel (ich hoffe) haben Sie gelernt, wie man Roh -Transaktionsdaten in sinnvolle geschäftliche Erkenntnisse verwandelt.

Denken Sie daran, dass die Datenanalyse die Datenanalyse wie das Kochen lernen – Sie beginnen mit grundlegenden Rezepten (wie den Beispielen in diesem Leitfaden) und werden nach und nach besser. Der Schlüssel ist Übung und Neugier.

Wenn Sie das nächste Mal einen Datensatz analysieren, fragen Sie sich:

• Welche Geschichte erzählt diese Daten?
• Welche Muster könnten hier versteckt sein?
• Welche Fragen könnten diese Daten beantworten?

Nutzen Sie dann Ihre neuen Polarsfähigkeiten, um dies herauszufinden. Viel Spaß bei der Analyse!

Bala Priya c ist ein Entwickler und technischer Schriftsteller aus Indien. Sie arbeitet gern an der Schnittstelle zwischen Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Ihre Interessensgebiete und Fachgebiete umfassen DevOps, Information Science und natürliche Sprachverarbeitung. Sie liest gerne, schreibt, codieren und Kaffee! Derzeit arbeitet sie daran, ihr Wissen mit der Entwicklergemeinschaft zu lernen und zu teilen, indem sie Tutorials, Anleitungen, Meinungsstücke und vieles mehr autorisiert. Bala erstellt auch ansprechende Ressourcenübersichten und Codierungs -Tutorials.

Bild von Autor | Leinwand

# Einführung

Gemini Cli ist Googles neuer AI-Assistent von Open-Supply, der in Ihrem Terminal ausgeführt wird. Es bringt das Gemini -Sprachmodell (Gemini 2.5 Professional) direkt in Ihre Shell, damit Sie Fragen stellen, Code generieren, Fehler beheben oder Dokumentation erstellen können, ohne die Befehlszeile zu verlassen. „Gemini“ selbst ist ein LLM und „Gemini Cli“ ist im Grunde ein Benutzerwerkzeug, das das Modell in Ihren Workflows interaktiv macht. Kurz gesagt, es ist wie Chatgpt für Entwickler. Google hat im Juni 2025 Gemini Cli veröffentlicht, und es ist FREI für Einzelpersonen. Sie müssen sich nur mit Ihrem persönlichen Google-Konto anmelden, und es erhalten Sie auf Gemini 2.5 Professional mit einem riesigen Kontextfenster von 1 Million kostenlos (bis zu 60 Anfragen/Minute und 1.000/Tag). Es ist eine großartige kostenlose und Open -Supply -Various zu KI -Codierungsassistenten wie dem Claude -Code von Anthropic.

Lassen Sie mich Ihnen beim Setup helfen und Sie durch einige Beispiele führen, um die Bedeutung hervorzuheben.

# Einrichten von Gemini CLI in Ihrem System

Um Gemini CLI zu installieren, benötigen Sie eine Befehlszeilenumgebung (Terminal auf MacOS/Linux, PowerShell oder ähnlichem unter Home windows) und entweder Homebrew oder Node.js. Auf macOS ist die einfachste Methode über Homebrew:

1. Installieren Sie Gemini CLI über Homebrew: Führen Sie den folgenden Befehl in Ihrem Terminal aus
2. Alternativ installieren Sie über Knoten (jedes Betriebssystem): Wenn Sie Homebrew bevorzugen oder nicht verwenden, installieren Sie Node.js (Model 20 oder höher. Dann rennen Sie:

npm set up -g @google/gemini-cli

oder

npx https://github.com/google-gemini/gemini-cli

Dies installiert die CLI weltweit auf MacOS, Linux oder Home windows. Node.js v20+ ist erforderlich; Sie können es herunterladen nodejs.org Oder verwenden Sie NVM, um Versionen zu verwalten.

Nach der Set up können Sie einfach den folgenden Befehl ausführen, um die Gemini-CLI zu starten:

Das sollte Starten Sie die CLI (Wenn Sie das „Gemini Cli“ ASCII -Banner sehen, sind Sie festgelegt). Wenn Gemini nicht gefunden wird, müssen Sie möglicherweise ein neues Terminal öffnen oder Ihrem Weg den globalen Bin von NPM hinzufügen. Sie werden so etwas sehen:

Screenshot des Gemini CLI -Begins

Im ersten Lauf fordert die Gemini CLI auf, ein Farbthema (hell oder dunkel) auszuwählen und sich dann mit Ihrem Google -Konto anzumelden. Befolgen Sie die Anweisungen im Browser (oder der CLI) zur Genehmigung. Wenn Sie es vorziehen, einen API -Schlüssel anstelle von Anmeldung zu verwenden, können Sie festlegen Gemini_api_key = „your_key“ In Ihrer Umgebung (siehe Google AI Studio, um einen Schlüssel zu generieren). Nach der Authentifizierung bestätigt die CLI, dass sie verwendet werden kann.

# Führen Sie Ihre ersten Gemini CLI -Befehle aus

Mit der Einrichtung von Gemini CLI können Sie sofort mit natürlichen Sprachbefehlen beginnen. Es öffnet eine Eingabeaufforderung (markiert markiert >) wo Sie Fragen oder Aufgaben eingeben. Versuchen wir zum Beispiel eine einfache Eingabeaufforderung und fragen Sie: „Schreiben Sie einen kurzen Absatz darüber, warum Gemini Cli großartig ist.“ Hier ist Ausgabe:

Screenshot von Gemini CLI: Einfaches Absatzschreiben

// Aufgabe 1: Behebung von Fehler mit Gemini CLI

Gemini CLI kann sich in Instruments wie GitHub oder Ihr lokales Git integrieren, um Probleme zu finden. Lassen Sie uns beispielsweise das integrierte @Search-Device zum Abrufen einer GitHub-Drawback-URL verwenden und dann nach einem Fixplan bitten:

Immediate (Supply):

Right here’s a GitHub subject: (@search https://github.com/google-gemini/gemini-cli/points/4715). Analyze the code and recommend a 3-step repair plan.

Die CLI identifizierte die Grundursache und schlug vor, wie der Code geändert werden soll. Der folgende Screenshot zeigt, dass es einen 3-Stufen-Plan meldet. Sie können den Plan überprüfen und dann bestätigen, dass Gemini CLI die Änderungen automatisch auf Ihre Dateien anwendet.

Screenshot von Gemini CLI: Behebung von Fehler

// Aufgabe 2A: Arbeiten mit einem Projekt (einfaches Beispiel)

Ich habe einen Projektordner erstellt, indem ich das Gitdiagram -Repo kloniert habe. Wenn Sie mehr über dieses Repo erfahren möchten, besuchen Sie meinen Artikel: Machen Sie ein 10K+ Line Github Repo, ohne den Code zu lesen. Navigieren wir zu unserem Projektordner mit:

Jetzt rennen Zwillinge. Sie können Fragen zum Code stellen. Versuchen wir die folgende Eingabeaufforderung:

Immediate:
Clarify the principle parts of this codebase

Gemini CLI scannt die Dateien und verwendet das Gemini -Modell, um zusammenzufassen oder zu antworten, wie im folgenden Screenshot gezeigt:

Screenshot von Gemini CLI: Arbeit mit einem Projekt (einfaches Beispiel)

Es analysierte die Ordner und gab eine strukturierte Zusammenfassung zurück (Auflistungsverzeichnisse wie SRC/, Public/usw.). Dies ist praktisch für das Onboarding in neuen Projekten oder die Generierung von Dokumentationen.

// Aufgabe 2B: Arbeiten mit einem Projekt (erweitertes Beispiel)

Die Erkundung der Codebasis ist einfach. Lassen Sie uns nun eine technische Aufgabe geben, um zu sehen, wie sich die Ausgabe entwickelt. Wir werden Gemini die folgende Aufforderung zur Verfügung stellen:

Immediate:
Analyze this repo for frequent efficiency anti-patterns.

Screenshot von Gemini CLI: Arbeit mit einem Projekt (Superior Beispiel)

Die Antwort struggle so detailliert, dass ich den Startteil nur in den Screenshot aufgenommen habe. Gemini CLI hat einen detaillierten Plan erstellt und dann jede Datei unabhängig voneinander gelesen. Am Ende teilte es eine Zusammenfassung der potenziellen Leistungs-Anti-Muster zusammen mit den empfohlenen nächsten Schritten:

Abstract of potential efficiency anti-patterns based mostly on preliminary evaluation:
   1. Massive Frontend Bundle Measurement:
       * Mermaid Library: The mermaid library is probably going a major contributor to the bundle measurement. If it is not
         lazy-loaded, it's going to impression preliminary web page load efficiency.
       * `react-icons`: Relying on the way it's imported, it may possibly additionally contribute to bundle measurement if not tree-shaken
         successfully.
   2. Unoptimized Picture Utilization: Whereas Subsequent.js has subsequent/picture, with out inspecting the precise picture utilization in parts,
      it is laborious to say if pictures are correctly optimized (e.g., right sizes, codecs, lazy loading).
   3. Potential Backend Efficiency Points (Python & Node.js):
       * N+1 Queries: This can be a frequent database anti-pattern that may considerably decelerate knowledge retrieval.
       * Lack of Caching: If regularly accessed knowledge is just not cached on the utility or database degree, it may possibly lead
         to redundant computations and database hits.
       * Synchronous Operations: Blocking I/O in both backend may result in efficiency bottlenecks underneath heavy load.
   4. `reactStrictMode: false`: Whereas not a direct anti-pattern, it may possibly cover potential efficiency points associated to
      React's rendering habits throughout improvement.
   5. Growth-like Docker Quantity Mount: Mounting all the backend listing within the Docker container is much less
      optimum for manufacturing builds in comparison with copying solely crucial recordsdata.

  To substantiate these, additional investigation can be wanted, together with:

   * Bundle Evaluation: Utilizing instruments like @subsequent/bundle-analyzer to establish giant modules within the frontend.
   * Efficiency Profiling: Working the applying and utilizing browser developer instruments (for frontend) and backend
     profiling instruments to establish bottlenecks.
   * Code Overview: Deep diving into the src/ and backend/ code to establish particular situations of the anti-patterns
     talked about.

Diese Beispiele zeigen, wie Gemini CLI einfache Eingabeaufforderungen in echte Aktionen verwandelt. Sie können Code abfragen, es generieren oder refaktorieren, Fehler beheben und die Leistung verbessern, alles aus Ihrem Terminal.

# Einpacken

Gemini Cli ist ein leistungsstarkes neues Werkzeug für Entwickler. Sobald Sie es auf MacOS (oder einem beliebigen Betriebssystem) installiert haben, können Sie mit Googles Gemini LLM von Google so einfach interagieren wie bei jedem lokalen Befehl. Einige der wichtigsten Funktionen, die es anders machen, sind:

1. React Agent Loop: Innen wird eine React Agent -Schleife mit Ihrer lokalen Umgebung durchgeführt. Dies bedeutet, dass Sie entscheiden können, wann Sie ein Device (suchen, ausführen, Shell ausführen, Datei bearbeiten) anrufen sollen, und wann direkt beantwortet werden soll. Zum Beispiel hat es bei Bedarf eine URL mit @search abgerufen.
2. Integrierte Werkzeuge: Es verfügt über integrierte „Instruments“ wie GREP, Echo, Datei lesen/schreiben und Sie können Websuche oder Dateisystemabfragen von Eingabeaufforderungen aufrufen.
3. Multimodale Funktionen: Gemini CLI kann sogar mit Bildern/PDFs arbeiten (da Gemini multimodal ist). Es unterstützt die Integration mit dem externen Modellkontext -Protokoll (MCP) -Server, z. Auf diese Weise können Sie Dinge wie „Code aus dieser Skizze generieren“ oder „einen PDF zusammenfassen“ tun.

Probieren Sie es aus: Öffnen Sie nach dem Befolgen des oben genannten Setups ein Terminal in einem Projektordner, geben Sie Gemini ein und beginnen Sie mit dem Experimentieren. Sie werden schnell sehen, wie ein KI -Begleiter in Ihrer Hülle Ihre Produktivität dramatisch steigern kann!

Kanwal Mehreen ist ein Ingenieur für maschinelles Lernen und technischer Schriftsteller mit einer tiefgreifenden Leidenschaft für die Datenwissenschaft und die Schnittstelle von KI mit Medizin. Sie hat das eBook „Produktivität mit Chatgpt maximieren“. Als Google -Technology -Gelehrte 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie wird auch als Teradata -Vielfalt in Tech Scholar, MITACS Globalink Analysis Scholar und Harvard Wecode Scholar anerkannt. Kanwal ist ein leidenschaftlicher Verfechter der Veränderung, nachdem er Femcodes gegründet hat, um Frauen in STEM -Bereichen zu stärken.

Bild von Editor | Chatgpt

# Einführung

Saiten sind einer der am häufigsten verwendeten Datentypen in Python. Es besteht eine hohe Wahrscheinlichkeit, dass Sie während Ihrer Entwicklungsreise oder Karriere bei der Arbeit mit Python auf die eine oder andere Weise Saiten verwenden, sei es als Datenwissenschaftler, Software program -Ingenieur, DevOps -Ingenieur oder einen ähnlichen Fachmann, der häufig mit Python zusammenarbeitet. Es ist eine unschätzbare Fähigkeit, die in jedem aufstrebenden Python -Entwickler -Toolkit mit Saiten zu arbeiten, um sie nahtlos zu arbeiten.

In diesem Artikel erfahren Sie über Saiten in Python und verschiedene Techniken, um sie zu manipulieren. Dieser Artikel eignet sich für Anfänger mit Kenntnissen der Python -Programmierung, die beabsichtigt, über Strings zu lernen und mit ihnen zu arbeiten, indem sie verschiedene Manipulationsmethoden erforschen.

# Was sind Saiten in Python?

Eine Zeichenfolge in Python ist ein primitiver Datentyp und ein Objekt der str Klasse. Als Objekt hat es Zugriff auf die vielen von der bereitgestellten Methoden str Klasse, die für die String -Manipulation verwendet werden kann. Der Baustein der Saiten sind Charaktere; Eine Zeichenfolge kann ein oder mehrere Zeichen enthalten, einschließlich Whitespace, die in doppelten oder einzelnen Zitaten eingeschlossen sind. Dies kann eine Zahl oder Folge von Zahlen, ein Buchstaben oder eine Folge von Buchstaben oder eine Kombination dieser und anderer Symbole sein.

Nachfolgend sind einige der wichtigsten Eigenschaften von Zeichenfolgen aufgeführt:

// Unveränderlichkeit

Saiten in Python sind unveränderlich, was bedeutet, dass sie nicht geändert werden können, sobald sie erstellt werden. Wenn Sie eine Zeichenfolge in Python erstellen, nimmt das Objekt einen Speicherplatz im Speicher ein. Dieses bestimmte Objekt kann nicht geändert werden; Jede Änderung oder Manipulation, die an dem Streichelobjekt vorgenommen wurde, führt eher zur Erstellung einer neuen Zeichenfolge.

Siehe den Beispielcode unten:

identify = "large"
print(identify.higher())
print(identify)

Ausgabe:

Der obige Code -Snippet zeigt, dass die Variable identify blieb auch unverändert, auch nachdem er das angerufen hatte higher() Methode darauf.

// Geordnete Natur

Saiten stellen eine geordnete Reihenfolge von Zeichen dar, die es jedem Zeichen in einer Zeichenfolge ermöglicht, eine bestimmte Place oder einen bestimmten Index zu haben.

// Indexierbar

Zeichen in einer Zeichenfolge können über ihren Index zugegriffen werden. Python -Indizes beginnen bei Null (0), was bedeutet, dass das erste Zeichen einer Zeichenfolge mit Index 0 zugegriffen werden kann.

// Iterabilität

Sie können jedes Zeichen in einer Zeichenfolge mit a durchlaufen for Schleife, um eine gewünschte Operation durchzuführen.

# Saiten in Python erstellen und verwenden

Befolgen Sie die folgenden Schritte, um eine Zeichenfolge in Python zu erstellen:

Schritt 1: Öffnen Sie Ihre IDE und erstellen Sie eine Datei für diese Übungsübung, z. B. follow.py.

Schritt 2: Erstellen Sie eine Variable und speichern Sie die darin gezeigte Zeichenfolge wie unten gezeigt:

my_string = "Howdy world, I simply created a string in Python"
print(my_string)

Führen Sie das Programm aus. Das struggle’s. Sie haben das zweifellos schon einmal gemacht.

Im obigen Beispiel haben wir einfach eine Zeichenfolge erstellt, sie in einer Variablen gespeichert und gedruckt. Es gibt jedoch viele andere Operationen, die wir mit Saiten durchführen können. Zum Beispiel können wir ein Programm schreiben, das eine Eingangszeichenfolge von einem Benutzer empfängt, es verarbeitet und eine Ausgabe druckt. Weitere Informationen finden Sie im Code -Snippet unten.

Erstellen Sie eine neue Datei mit dem Namen practice2.py und schreiben Sie den folgenden Code darin:

identify = enter("What's your identify: ")
print(f"Welcome {identify}, thanks for utilizing our program.")

Wenn Sie das Programm ausführen, sollten Sie eine interaktive Shell sehen.

Im obigen Code haben wir ein Programm erstellt, das einen Benutzer nach seinem Namen auffordert und eine Grußnachricht zurückgibt. Der Identify des Benutzers wurde in einer Variablen gespeichert (identify) und später im Programm verarbeitet, um Teil der Ausgabenachricht zu sein. Ein F-String wurde verwendet, indem der Transient platziert wurde f Vor den Doppelzitaten. Innerhalb der Zitate die identify Die Variable wird zwischen lockigen Klammern platziert. F-Sace stellen sicher, dass Ausdrücke in lockigen Klammern bewertet werden, weshalb der in der gespeicherte Wert der gespeicherte Wert identify Nach dem Ausführen des Programms wurde die Variable in die Konsole gedruckt.

# Saiten in Python manipulieren

String Manipulation ist der Prozess, bei dem Strings programmatisch verändert oder geändert werden, um einen bestimmten Zweck zu erfüllen. Bei ordnungsgemäßer Verwendung hat die String -Manipulation zahlreiche Vorteile. Beispielsweise könnte ein Datenwissenschaftler es verwenden, um einen Datensatz zu reinigen, oder ein Software program -Ingenieur könnte damit die Texteingabe verarbeiten.

Python wird mit vielen integrierten Methoden ausgestattet, mit denen Sie Strings manipulieren können, wie Sie unten aufgeführt sind.

// Wechseln zwischen Großbuchstaben und Kleinbuchstaben

Um eine Zeichenfolge in Großbuchstaben zu wechseln, rufen Sie einfach die an higher() Methode in der Zeichenfolge wie unten gezeigt:

identify = "John"
uppercase_name = identify.higher()
print(uppercase_name)

Ausgabe:

Sie können auch eine Schnur aus Großbuchstaben in Kleinbuchstaben konvertieren, indem Sie die anrufen decrease() Methode auf der uppercase_name Variable.

print(uppercase_name.decrease())

Ausgabe:

// Substrings ersetzen

Wenn Sie jemals ein Substring durch etwas anderes ersetzen müssen, die exchange() Methode ist Ihre Anlaufstelle. Es ersetzt alle Ereignisse des vorhandenen Substrings durch eine andere und gibt eine neue Zeichenfolge zurück. Da Saiten unveränderlich sind, müssen Sie das Ergebnis einer neuen Variablen zuweisen.

textual content = "Howdy strangers"
new_text = textual content.exchange("strangers", "household")
print(new_text)

Ausgabe:

// Spaltung einer Zeichenfolge

Eine Zeichenfolge kann in eine Liste von Substrings aufgeteilt werden cut up() und ein bestimmter Trennzeichen.

textual content = "Howdy, World"
print(textual content.cut up(","))

Außerut:

// Schließe Saiten

Während die cut up() Die Methode trennt eine Zeichenfolge in eine Liste, die be a part of() Die Methode verbindet die Elemente einer Liste mit einem ausgewählten Trennzeichen in eine einzelne Zeichenfolge.

phrases = ("Howdy", "World")
print(" ".be a part of(phrases))

Ausgabe:

// Zählen von Substring -Ereignissen

Der depend() Die Methode wird verwendet, um die Häufigkeit zu ermitteln, mit der ein Substring in einer Zeichenfolge angezeigt wird.

textual content = "Howdy World"
print(textual content.depend("l"))

// Zählungslänge

Die Länge einer Saite kann berechnet werden, indem das integrierte Integration aufgerufen wird len() Funktion.

textual content = "Howdy World"
print(len(textual content))

// Entfernen Sie Weißespace oder angegebene Zeichen aus String

Die Whitespace zu Beginn (führend) und das Ende einer Saite können entfernt werden. Der lstrip() Methode entfernt die Führung der Whitespace und rstrip() Entfernt die nachverfolgende Weiße. Der strip() Methode entfernt beide. Es kann auch verwendet werden, um angegebene führende und nachfolgende Zeichen zu entfernen.

# Instance string with further areas and symbols
textual content = "   **Howdy World!!**   "

# Utilizing strip() to take away areas from either side
stripped_text = textual content.strip()
print(stripped_text)"

# Utilizing lstrip() to take away areas from the left facet
left_stripped_text = textual content.lstrip()
print(left_stripped_text)

# Utilizing rstrip() to take away areas from the precise facet
right_stripped_text = textual content.rstrip()
print(right_stripped_text)

# Utilizing strip() to take away particular characters (*, !, and areas) from either side
custom_stripped_text = textual content.strip(" *!")
print(custom_stripped_text)

# Utilizing lstrip() to take away particular characters (*, !, and areas) from the left facet
custom_left_stripped_text = textual content.lstrip(" *!")
print(custom_left_stripped_text)

# Utilizing rstrip() to take away particular characters (*, !, and areas) from the precise facet
custom_right_stripped_text = textual content.rstrip(" *!")
print(custom_right_stripped_text)

Ausgabe (in der Reihenfolge des Betriebs):

"**Howdy World!!**"
"**Howdy World!!**   "
"   **Howdy World!!**"
"Howdy World"
"Howdy World!!**   "
"   **Howdy World"

// Überprüfungsfall

Um zu überprüfen, ob alle Zeichen in einer Zeichenfolge ein bestimmter Fall sind, können Sie die verwenden isupper() oder islower() Methoden. Diese Methoden geben einen Booleschen Wert zurück (True oder False).

print("HELLO".isupper())
print("hi there".islower())
print("HeLLo".islower())

# Abschluss

In diesem Artikel wurden Sie in Streicher vorgestellt und erklärt, wie sie in Python programmatisch interagieren können. Sie haben gelernt, welche Saiten sie sind und wie sie mit einigen integrierten Methoden in Python erstellt, verwendet und manipuliert werden können. Obwohl dieser Artikel nicht alle Methoden zur Streichmanipulation abdeckte, hat er die grundlegenden Prinzipien für die Manipulation von Saiten festgelegt.

Üben Sie die Beispiele in diesem Artikel selbst, um Ihr Lernen zu konsolidieren.

Danke fürs Lesen.

Shittu Olumide ist ein Software program-Ingenieur und technischer Autor, der sich leidenschaftlich für die Nutzung hochmoderner Technologien für überzeugende Erzählungen befindet, mit einem scharfen Auge für Particulars und einem Händchen zur Vereinfachung komplexer Konzepte. Sie können auch Shittu finden Twitter.

Bild von Autor | Ideogramm

Einführung

Lufttable ist eine Cloud-basierte, benutzerfreundliche und kI-gesteuerte Plattform zum Erstellen, Verwalten und Freigeben von Datenbanken. Es kombiniert die besten Excel -Tabellen mit relationalen Datenbankverwaltungssystemen. Airtable bietet ein Freemium -Abonnementmodell an, bei dem einige begrenzte Funktionen kostenlos verwendet werden können, was es very best für kleinere Projekte oder Anfänger macht, während die kostenpflichtige Model erweiterte Funktionen und eine größere Menge an Rechenressourcen bietet.

Dieser Artikel bietet einen Ausgangspunkt für alle, die sich für Airtable interessieren und was er auf Anfängerebene zu bieten hat, insbesondere für die Datenanalyse. Der Artikel führt Sie durch den Prozess des Erstellens einer neuen Airtable -App, die einige Daten enthält und sie für einige grundlegende Analyseberechnung verwendet.

Anmelden und Erstellen Ihres ersten Projekts

Als Cloud-basiertes Software muss Airtable keine Desktop-Anwendung herunterladen, sondern einfach auf die zugreifen Webseite und anmelden. Wenn Sie zum Beispiel ein Google-Konto haben, können Sie es für eine schnelle Anmeldung verwenden. Andernfalls besteht die Möglichkeit, sich über eine E -Mail -Adresse zu registrieren.

Nach der Anmeldung sind wir bereit, unser erstes Projekt zu erstellen. In Airtable das Konzept von Base oder App ist analog zu einem Projekt oder einer App – im Wesentlichen einen Container für alle Daten – additionally erstellen wir eine neue Foundation. Wenn Sie auf den ersten Blick die Schaltfläche „leere App erstellen“ nicht sehen können, müssen Sie möglicherweise nach der unteren linken Ecke nach „Erstellen“ -Style oder alternativ nach einem „X“ -Image an der oberen rechten Ecke suchen. Klicken Sie darauf, und Sie werden aufgefordert, eine leere App zu erstellen.

Sie sollten dann einen solchen Bildschirm sehen:

Neue Foundation (Projekt) in Airtable

Jetzt ist es Zeit, einige Daten zu importieren. Lufttable Basen bestehen aus einem oder mehreren Tischen. Standardmäßig erscheint eine leere Tabelle mit dem Namen „Tabelle 1“. Daneben gibt es eine Registerkarte, die aufgerufen wird „+ Hinzufügen oder Importieren„Auf Airtable klicken wir auf, um unser Projekt beispielsweise aus Tabellenkalkulationen in Google -Blättern oder Excel, Salesforce, Google Drive, Trello und vielen anderen Daten hinzuzufügen. Wir werden einen der einfachsten Ansätze verwenden: Hochladen einer CSV -Datei, konkret aus einer URL.CSV -Datei„, und auf der linken Seite des aufkommenden Fensters wählen Sie“Hyperlink (URL)„, wie unten gezeigt:

Hochladen von CSV -Daten über URL

Kopieren Sie die folgende URL in einen Datensatz, den ich in GitHub für Sie zur Verfügung gestellt habe, und fügen Sie sie in das angezeigte Textfeld ein. Klicken Sie dann auf die rechte Blue-Schaltfläche, und wenn Sie aufgefordert werden, eine neue Tabelle zu erstellen oder eine vorhandene zu verwenden, stellen Sie sicher, dass Sie eine neue Tabelle erstellen. Seien Sie nicht versucht, die vorhandene Standardtabelle mit dem Namen „Tabelle 1“ zu verwenden, da dieses Tabellenschema nicht mit dem des von uns importierten Datensatzes kompatibel ist.

Das warfare’s! Sie haben jetzt eine neue Tabelle mit den importierten Daten, die Aufzeichnungen von enthält Kunden in einem Einkaufszentrummit den folgenden Attributen:

• Kundenausweis: Die numerische Kennung eines Kunden.
• Geschlecht: Das Geschlecht des Kunden, nämlich männlich oder weiblich.
• Alter: Das Alter des Kunden wird als Ganzzahl ausgedrückt.
• Einkommen: Das Jahreseinkommen des Kunden in Tausenden von US -Greenback ($).
• Ausgabenbewertung: Eine normalisierte Punktzahl zwischen 1 und 100 der Ausgabenstufe des Kunden.

Anfängerdatenanalyse

In der importierten Tabelle sind alle Spalten vom Typ numerischer Typ, mit Ausnahme von „Geschlecht“, das kategorisch ist. In Airtable wird eine kategoriale Spalte mit einem möglichen Wert professional Instanz unter einem vordefinierten Satz „Single Choose“ bezeichnet. Sie können die Eigenschaften von „Geschlecht“ oder einem anderen Feld prüfen oder ändern, indem Sie auf dem Spaltenkopf gehalten, auf das angezeigte V-like-Image klicken und „Feld bearbeiten“ auswählen. Für dieses Tutorial werden wir sozusagen Spaltentypen verlassen und eine Analyse durchführen.

Kunden nach Geschlecht gruppieren: Gruppierungsdatensätze nach Werten eines kategorialen Attributs sind so einfach wie das Klicken auf die Schaltfläche „Gruppen“ über der Tabelle. Wählen Sie „Geschlecht“ und dann „Collapse ALL“, um aggregierte Zusammenfassungen Ihrer Daten für jedes Geschlecht zu sehen. Standardmäßig sehen Sie die Gesamt (Summe) der Werte professional Attribut und Geschlecht, aber Sie können auch die durchschnittlichen (oder Median, min, max usw.) Werte von Spalten wie Einkommen, Ausgabenbewertungen usw. sehen. Dies kann wie im folgenden Screenshot gezeigt werden:

Analysieren von Gruppedkunden nach Geschlecht

Wir können beobachten, dass Männer im Durchschnitt ein höheres Einkommen haben als Frauen, aber Frauen mehr als Männer ausgeben.

Durchschnittliches Einkommens- und Ausgabenwert nach Geschlecht

Um eine Gruppierung der Daten zu entfernen, klicken Sie einfach erneut auf das Image „Gruppe“ und klicken Sie dann auf das Bin -Image neben der erstellten Gruppierung, um sie zu entfernen und Ihre vollständige, ungruppierte Tabelle erneut anzusehen.

Filterung junger Kunden: Als nächstes versuchen wir, eine Filterung durchzuführen. Dies ist ein einfacher und intuitiver Betrieb, der im „Filter“ -Image neben dem zuvor verwendeten „Gruppen“ -Image erhältlich ist. Wählen Sie im Dialogfeld Popup „+ Bedingung hinzufügen“. Eine Filterbedingung besteht aus drei Elementen: einem Feld- oder Spaltennamen, einem Operator und einem Wert. Beispiele für Bedingungen sind „Alter> = 39“, „Ausgabenbewertung = 10“, „Geschlecht ist nicht männlich“ usw. Um junge Kunden zu filtern, werden wir den Zustand „Alter <30" festlegen. Dies sollte insgesamt 55 Kunden filtern. Eine interessante Sache zu diesem Zeitpunkt ist es, den Filter zu kombinieren, der mit (einmal) einer Gruppierung nach Geschlecht hergestellt wurde, um zu überprüfen, ob die Ergebnisse über Einkommens- und Ausgabenbewertungen bei Männern gegenüber Frauen immer noch für junge Kunden gelten. Sobald Sie dies ausprobiert haben, können Filter leicht zu Gruppierungen entfernt werden.
Verwenden von Formeln zur Definition eines Felds „Einkommensklasse“: Airtable ermöglicht die Erstellung neuer Säulen unter vielen verschiedenen Ansätzen, wobei Formeln eine davon sind. Klicken Sie einfach auf die Schaltfläche „+“ neben der rechten Spalte in Ihrer Tabelle, um eine neue Spalte hinzuzufügen, und wählen Sie „Formel“ als Erstellungsmethode oder Spaltentyp. Zum Beispiel können wir die folgende Formel verwenden:

IF({Annual Revenue (ok$)} < 40, "Low",
IF({Annual Revenue (ok$)} < 70, "Medium", "Excessive"))

Um eine neue Spalte namens „Einkommensklasse“ zu erstellen, deren Werte (Kategorien) je nach Wert der jährlichen Einkommensspalte definiert werden, indem die obige Formel aus zwei verschachtelten Bedingungen folgt. Wenn Sie nicht mit der Syntax der Tabellenkalkulationsformeln vertraut sind, gibt es keine Panik, es gibt eine „Formel erstellen mit KI“ -Style, bei der AI-Assistent von Airtable helfen kann, eine Formel basierend auf Ihren Spezifikationen oder Ihrem Ziel zu erstellen.

Verwenden von Formeln zum Erstellen einer neuen Spalte

Verwenden von Schnittstellen, um Ihre Daten zu visualisieren: Lufttable Schnittstellen werden verwendet, um Datenvisualisierungen zu generieren. Diese Funktion ist in der kostenlosen Stufe begrenzt, aber es ist immer noch möglich, einfache Dashboards mit Elementen wie Balkendiagrammen und Drehstabs-Tabellen zu erstellen. Um eine Schnittstelle zu erstellen, klicken Sie in der oberen Symbolleiste auf „Schnittstellen“ und befolgen Sie die Schritte der Assistenten. Möglicherweise bekommen Sie etwas wie dieses Dashboard:

Schnittstellen -Dashboard in Airtable

Beachten Sie, dass Schnittstellen unter Groups, z. B. für die Förderung von Enterprise Intelligence -Prozessen, gemeinsam genutzt werden können.

Einpacken

In diesem Artikel wurde Airtable eingeführt, eine vielseitige und benutzerfreundliche Cloud-basierte Plattform für die Datenverwaltung und -analyse, die Funktionen von Tabellenkalkulationen und relationalen Datenbanken mit KI-angetriebenen Funktionen kombiniert. Der in diesem Artikel bereitgestellte Leitfaden soll neue Benutzer in die Luftanalyse vorstellen und einige grundlegende Funktionen für die Datenanalyse skizzieren. Obwohl sie nicht unser Hauptaugenmerk waren, sind die KI -Funktionen, die das Software bereitgestellt hat, wohl einer der empfohlenen nächsten Schritte, die über diesen Punkt hinaus erkunden können.

Iván Palomares Carrascosa ist ein Führer, Schriftsteller, Sprecher und Berater in KI, maschinellem Lernen, Deep Studying & LLMs. Er trainiert und führt andere darin, KI in der realen Welt zu nutzen.

Bild von Autor | Ideogramm

Wir leben in einer aufregenden Ära, da die generative KI als Werkzeug herausgestellt hat, das unsere Arbeit erheblich verbessert. Seit der Einführung von Produkten wie ChatGPT hat sich das Aufkommen großer Sprachmodelle (LLMs) grundlegend verändert, in denen wir leben und arbeiten.

Google als Unternehmen würde sicherlich nicht die Likelihood geben, eigene LLM -Produkte zu entwickeln, wie das Gemini -Modell zeigt. Darüber hinaus besitzt Google bereits viele nützliche Produkte wie Google Sheets. Google hat einen fantastischen Schritt gemacht, indem sie Gemini direkt in Google Sheets integriert werden kann.

Da Google Sheets von vielen Unternehmen verwendet wird, wird es hilfreich sein zu verstehen, wie wir Gemini AI darin verwenden können. In diesem Artikel werden wir die Implementierung von Gemini mit Google Sheets durchlaufen.

Neugierig? Lass uns eintauchen!

Google Gemini in Google Sheets

Nach der offiziellen Ankündigung durch Google die aktuelle Tabelle Ai (Gemini in Google Sheets) ist bereits für die Öffentlichkeit verfügbar, jedoch nur über das Google Workspace -Abonnement. Um es auszuprobieren, können Sie ihre erkunden Preispläne und nutzen Sie die verfügbare kostenlose Testversion.

Bevor wir Google Gemini in Google Sheets ausprobieren, müssen wir es auch zur Verfügung stellen, da die Funktion standardmäßig nicht automatisch eingeschaltet ist und dass wir ein Google Workspace Admin -Konto haben. Navigieren Sie zum Admin -Dashboard und aktivieren Sie Gemini für Google Workspace, indem Sie die Alpha -Funktionen innerhalb der generativen KI -Registerkarten einschalten.

Sobald die Funktionen aktiviert sind, versuchen Sie, ein neues Google -Blatt mit Ihrem Google Workspace -Konto zu erstellen. Nach dem Öffnen einer neuen Datei sehen Sie das Icon ** Gemini **, ähnlich dem Bild unten.

Dies ist Ihr Gemini -Assistent, bei dem Sie etwas fragen und Gemini leiten können, bestimmte Aktionen in Google Sheets auszuführen. Wenn Sie sich nicht sicher sind, was Sie tun können, können Sie Gemini in der Eingabeaufforderung immer „was Gemini tun“ fragen.

Zum Beispiel können wir Google Gemini bitten, eine neue Tabelle zu erstellen und sie in unsere Blätter einfügen, ähnlich wie das Bild unten.

Indem wir vorhandenen Dateien oder Tabellen in Google Sheets verweisen, können wir das Gemini -Modell um weitere Analysen oder Vorschläge bitten. Zum Beispiel konnten wir Gemini nach Erkenntnissen aus unseren Daten und Vorschlägen für Diagramme bitten, die wir entwickeln konnten, wie im Bild unten gezeigt.

Im Wesentlichen können Sie Gemini alles fragen, und das Modell schlägt vor oder liefert Aktionen, die für Ihren Workflow geeignet sind.

Darüber hinaus können Sie direkt auf der Ebene von Google Sheet Cell mit Gemini arbeiten, was durch die erleichtert wird =AI Formel. Die Formel ermöglicht derzeit die Erzeugung, Zusammenfassung und Klassifizierung von Textual content.

Der =AI Die Formel erfordert zwei Parameter: die Eingabeaufforderung (oder Anweisung) und einen optionalen Referenzzellbereich. Beginnen wir mit dem generieren ein neues Etikett mit dem =AI Formel. Zum Beispiel könnten wir versuchen, einen Dokumentnamen basierend auf den Daten zuzuweisen, die wir haben.

=AI("Generate a doc identify appropriate for this row", A2:F2)

Drücken Sie dann die Style „Erzeugen und einfügen“, um die Formel auszuführen.

Einmal der =AI Die Formel wird ausgeführt. Sie können sie in die Zellen unterhalb der Ersten ziehen, um sie auf alle verfügbaren Daten anzuwenden. Zum Beispiel können wir Dokumentnamen in fünf verschiedenen Zellen generieren, wie unten gezeigt.

Sie können sich sogar auf die gesamte Tabelle beziehen und die folgende Formel verwenden, um den Datensatz zusammenzufassen.

=AI("Summarize the information in a single line", Table1)

Das Ergebnis sind Textdaten, die der folgenden Ausgabe ähneln.

The desk outlines challenge administration approaches, detailing their traits, benefits, disadvantages, appropriate purposes, and danger ranges.

Dadurch wird die grundlegende Einführung in den Zugriff auf und implementiert, um das Gemini -Modell in Google -Blättern zu ergreifen. Sie können weiter untersuchen und sehen, wie das Modell Ihre Datenanalyse beschleunigen kann.

Abschluss

Google Gemini ist zu einem Grundprodukt geworden, das Menschen ihre Arbeit unterstützt, indem sie Textual content basierend auf einer natürlichen Sprache generiert. Derzeit hat Google das Gemini -Modell über Google Workspace in Google Sheets integriert, auf das wir nach dem Abonnieren des Plans zugreifen können.

In diesem Artikel haben wir gelernt, wie man Google Gemini direkt in Google Sheets verwendet, sowohl über die Gemini -Seitenleiste als auch mit der Verwendung der Gemini =AI Formel.

Ich hoffe das hat geholfen!

Cornellius Yudha Wijaya ist ein Information Science Assistant Supervisor und Datenautor. Während er in Vollzeit bei Allianz Indonesien arbeitet, liebt er es, Python- und Datentipps über soziale Medien und das Schreiben von Medien zu teilen. Cornellius schreibt über eine Vielzahl von KI- und maschinellen Lernthemen.