Norwood, MA – 17. Dezember 2025 – Superior Thermal Options, Inc. (ATS) hat eine Reihe von Kühlkörpern vorgestellt, die für NVIDIA Jetson Thor-Module für das Wärmemanagement für Edge-Computing, physische KI und Robotikplattformen entwickelt wurden. Die Kühlkörper umfassen aktive und passive Kühloptionen.

Ein aktiver Jetson Thor-Kühlkörper verfügt über einen rahmenlosen Lüfter, der in sein Aluminiumlamellenfeld eingebettet ist. Dieser Kühlkörper kann 95-W-TDP-Geräte auf 50 °C kühlen. Die Abmessungen betragen 87 x 100,8 x 20 mm (L x B x H), bei einem Gewicht von 104 g.

Der andere aktive Kühlkörper verwendet ein leistungsstarkes, oben montiertes ATS-Gebläse, das Geräte mit einer TDP von 175 W bei 50 °C kühlen kann. Die Maße betragen 92 x 100,8 x 28,6 mm (L x B x H), inklusive Gebläse. Es wiegt 174g.

Der passive Aluminiumkühlkörper bietet bis zu 100 W Kühlung bei 50 °C und einem Systemluftstrom von 500 LFM. Die Abmessungen betragen 87 x 100,8 x 20 mm (L x B x H) und das Gewicht beträgt 168 g.

Alle Versionen der von NVIDIA Jetson Thor unterstützten Kühlkörper werden mit einem vormontierten Hochleistungs-Thermalschnittstellenmaterial (TIM) zur Verbesserung der Wärmeübertragung geliefert.

Die beispiellose Rechendichte von Jetson Thor steigert die thermischen Anforderungen über das hinaus, was herkömmliche eingebettete Kühllösungen unterstützen können. Die neuen ATS-Kühlkörper sind so konzipiert, dass sie die Leistungsstabilität auch bei kontinuierlichem Hochleistungsbetrieb aufrechterhalten und sicherstellen, dass KI-Workloads mit Vollgas laufen, ohne dass die thermische Leistung beeinträchtigt wird.

Die Module der NVIDIA Jetson Thor-Serie liefern bis zu 2070 FP4 TFLOPS KI-Rechenleistung und 128 GB Speicher bei einer Leistung von 40–130 W und stellen damit einen großen Sprung für physische KI und Robotik dar.

ATS bietet Kühllösungen für alle Jetson SOMs. Detaillierte Spezifikationen zu den ATS-Kühlkörpern für Jetson Thor-Module, die sofort lieferbar sind, finden Sie unter qats.com,.

In einem früheren Tutorial haben wir behandelt Die Grundlagen von Python for Schleifenuntersuchen, wie man über Hear und Hear von Hear iteriert. Aber es gibt noch viel mehr zu tun for Schleifen als durch Hear abschließend! In realer Datenwissenschaftsarbeit möchten Sie möglicherweise Superior Python verwenden for Schleifen mit anderen Datenstrukturen, einschließlich Numpy Arrays und Pandas DataFrames.

Dieses Tutorial beginnt mit der Verwendung for Schleifen, die durch gemeinsame Python -Datenstrukturen als Hear (wie Tupel und Wörterbücher) iteriert werden. Dann werden wir uns mit dem Gebrauch einlassen for Schleifen im Tandem mit gemeinsamen Python -Datenwissenschaftbibliotheken wie numpyAnwesend pandasUnd matplotlib. Wir werden uns auch das genauer ansehen vary() Funktion und wie es beim Schreiben nützlich ist for Schleifen.

Bevor wir anfangen, möchten Sie sich vielleicht ansehen Der vollständige Python -Leitfaden von DataQuest für Anfänger.

Eine kurze Bewertung: die Python for Schleife

A for Loop ist eine Programmieranweisung, die Python sagt, er solle eine Sammlung von Objekten iterieren und die gleiche Operation für jedes Objekt nacheinander ausführen. Die grundlegende Syntax ist:

for object in collection_of_objects:
    # code you wish to execute on every object

Jedes Mal, wenn Python durch die Schleife iteriert, die Variable object übernimmt den Wert des nächsten Objekts in unserer Sequenz collection_of_objectsund Python führt den Code aus, von dem wir in jedem Objekt geschrieben haben collection_of_objects nacheinander.

Lassen Sie uns nun in den Einsatz eingehen for Schleifen mit verschiedenen Arten von Datenstrukturen. Wir werden Hear überspringen, da diese im vorherigen Tutorial behandelt wurden. Wenn Sie eine weitere Überprüfung benötigen, lesen Sie die Einführend Python for Loops Tutorial oder DataQuest Interaktive Lektion auf Hear und for Schleifen.

Datenstrukturen

Tupel

Tupel sind Sequenzen, genau wie Hear. Der Unterschied zwischen Tupeln und Hear besteht darin, dass Tupel unveränderlich sind; das heißt, sie können nicht geändert werden (Erfahren Sie mehr über veränderliche und unveränderliche Objekte in Python). Tupel verwenden auch Klammern anstelle von quadratischen Klammern.

Unabhängig von diesen Unterschieden ist das Schleifen über Tupel sehr ähnlich zu Hear.

x = (10, 20, 30, 40, 50)
for var in x:
    print("index "+ str(x.index(var)) + ":", var)

index 0: 10
index 1: 20
index 2: 30
index 3: 40
index 4: 50

Wenn wir eine Liste von Tupeln haben, können wir auf die einzelnen Elemente in jedem Tupel in unserer Liste zugreifen, indem wir sie beide als Variablen in der einbeziehen for Schleife wie so:

x = ((1,2), (3,4), (5,6))

for a, b in x:
    print(a, "plus", b, "equals", a+b)

1 plus 2 equals 3
3 plus 4 equals 7
5 plus 6 equals 11

Wörterbücher

Zusätzlich zu Hear und Tupeln sind Wörterbücher ein weiterer häufiger Python -Datentyp, auf den Sie beim Arbeiten mit Daten wahrscheinlich begegnen, und for Schleifen können auch durch Wörterbücher iterieren.

Python-Wörterbücher bestehen aus Schlüsselwertpaaren, sodass in jeder Schleife zwei Elemente, auf die wir zugreifen müssen (den Schlüssel und den Wert). Anstatt zu verwenden enumerate() Wie wir es mit Hear tun würden, um beide Schlüsseln und die entsprechenden Werte für jedes Schlüsselwertpaar zu überschreiten, müssen wir das aufrufen .gadgets() Verfahren.

Stellen Sie sich zum Beispiel vor, wir haben ein Wörterbuch namens shares Das enthält sowohl Aktienkarten als auch die entsprechenden Aktienkurse. Wir werden die verwenden .gadgets() Methode in unserem Wörterbuch zum Generieren eines Schlüssels und Werts für jede Iteration:

shares = {
        'AAPL': 187.31,
        'MSFT': 124.06,
        'FB': 183.50
    }

for key, worth in shares.gadgets() :
    print(key + " : " + str(worth))

AAPL : 187.31
MSFT : 124.06
FB : 183.5

Beachten Sie, dass die von uns ausgewählten Variablennamen (key Und worth) sind völlig willkürlich – nun nicht völlig willkürlich Da wir uns für beschreibende Namen für sie entschieden haben, was immer eine gute Idee ist, wenn wir uns für variable Namen entscheiden! Alles in allem hätten wir diese Variablen als initialisieren können ok Und v oder x Und y Wenn wir wollten.

Saiten

Wie im Einführungs -Tutorial erwähnt, for Schleifen können auch durch jedes Zeichen in einer Saite iterieren. Als kurze Bewertung funktioniert das, wie das funktioniert:

print("information science")  
for c in "information science":
    print(c)

information science
d
a
t
a

s
c
i
e
n
c
e

Numpy Arrays

Schauen wir uns nun an, wie for Schleifen können mit gemeinsamen Python -Datenwissenschaftspaketen und ihren Datentypen verwendet werden.

Wir werden uns zunächst ansehen, wie man benutzt for Schleifen mit numpy Arrays, additionally beginnen wir damit, einige Arrays von Zufallszahlen zu erstellen.

import numpy as np

np.random.seed(0)  
x = np.random.randint(10, measurement=6)
y = np.random.randint(10, measurement=6)

Das Iterieren über ein eindimensionales Numpy-Array ist dem Iterieren einer Liste sehr ähnlich:

for val in x:
    print(val)

5
0
3
3
7
9

Was ist, wenn wir durch ein zweidimensionales Array iterieren wollen? Wenn wir dieselbe Syntax verwenden, um ein zweidimensionales Array wie oben zu iterieren, können wir bei jeder Iteration nur ganze Arrays wiederholen.

z = np.array((x, y))

for val in z:
    print(val)

(5 0 3 3 7 9)
(3 5 2 4 7 6)

Ein zweidimensionales Array wird aus einem Paar eindimensionaler Arrays aufgebaut. Um jedes Factor und nicht jedes Array zu besuchen, können wir die Numpy -Funktion verwenden nditer()ein mehrdimensionales Iteratorobjekt, das ein Array als Argument nennt.

Im folgenden Code schreiben wir a for Schleife, die jedes Factor durch Passieren iteriert zunser zweidimensionales Array, als Argument für nditer():

for val in np.nditer(z):
    print(val)

5
0
3
3
7
9
3
5
2
4
7
6

Wie wir sehen können, listet dies zuerst alle Elemente in x, dann alle Elemente von y auf.

Erinnern! Wenn Sie diese verschiedenen Datenstrukturen durchlaufen, benötigen Wörterbücher a VerfahrenNumpy Arrays benötigen a Funktion.

Pandas DataFrames

Wenn wir mit Daten in Python arbeiten, verwenden wir oft pandas Datenrahmen. Und zum Glück können wir benutzen for Schleifen auch durch diese iterieren.

Üben wir dies, während wir mit der Arbeit mit dem Arbeiten arbeiten Eine kleine CSV -Datei Dadurch werden das BIP, die Hauptstadt und die Bevölkerung für sechs verschiedene Länder aufgezeichnet. Wir werden dies unten in einem Pandas -Datenframe lesen.

Pandas arbeitet etwas anders als Numpy, sodass wir den Numpy -Prozess, den wir bereits gelernt haben, nicht einfach wiederholen können. Wenn wir versuchen, über einen Pandas -Datenfreame wie ein Numpy -Array zu iterieren, würde dies nur die Spaltennamen ausdrucken:

import pandas as pd
df = pd.read_csv('gdp.csv', index_col=0)

for val in df:
    print(val)

Capital
GDP ($US Trillion)
Inhabitants 

Stattdessen müssen wir explizit erwähnen, dass wir über die Zeilen des Datenrahmens iterieren möchten. Wir tun dies, indem wir das anrufen iterrows() Methode auf dem DataFrame- und Drucken von Zeilenbezeichnungen und Zeilendaten, wobei eine Zeile die gesamte Pandas -Serie ist.

for label, row in df.iterrows():
    print(label)
    print(row)

Eire
Capital                Dublin
GDP ($US Trillion)     0.3337
Inhabitants            4784000
Identify: Eire, dtype: object
United Kingdom
Capital                 London
GDP ($US Trillion)       2.622
Inhabitants            66040000
Identify: United Kingdom, dtype: object
United States
Capital               Washington, D.C.
GDP ($US Trillion)               19.39
Inhabitants                   327200000
Identify: United States, dtype: object
China
Capital                  Beijing
GDP ($US Trillion)         12.24
Inhabitants            1386000000
Identify: China, dtype: object
India
Capital                New Delhi
GDP ($US Trillion)         2.597
Inhabitants            1339000000
Identify: India, dtype: object
Germany
Capital                 Berlin
GDP ($US Trillion)       3.677
Inhabitants            82790000
Identify: Germany, dtype: object

Wir können auch auf bestimmte Werte aus einer Pandas -Serie zugreifen. Angenommen, wir möchten nur die Hauptstadt jedes Landes ausdrucken. Wir können angeben, dass wir nur aus der Spalte „Kapital“ wie SO OUTIONIEREN möchten:

for label, row in df.iterrows():
    print(label + " : " + row("Capital"))

Eire : Dublin
United Kingdom : London
United States : Washington, D.C.
China : Beijing
India : New Delhi
Germany : Berlin

Um die Dinge weiter zu nehmen als einfache Ausdrucke, fügen wir eine Spalte mit a hinzu for Schleife. Fügen wir ein BIP -Professional -Kopf -Spalte hinzu. Denken Sie daran .loc() ist labelbasiert. In dem folgenden Code fügen wir die Spalte hinzu und berechnen ihren Inhalt für jedes Land, indem wir sein Gesamt -BIP von ihrer Bevölkerung trennen und das Ergebnis um eine Billion multiplizieren (da die BIP -Nummern in Billionen aufgeführt sind).

for label, row in df.iterrows():
    df.loc(label,'gdp_per_cap') = row('GDP ($US Trillion)')/row('Inhabitants ') * 1000000000000
print(df)

                         Capital  GDP ($US Trillion)  Inhabitants   
Nation                                                             
Eire                   Dublin              0.3337      4784000   
United Kingdom            London              2.6220     66040000   
United States   Washington, D.C.             19.3900    327200000   
China                    Beijing             12.2400   1386000000   
India                  New Delhi              2.5970   1339000000   
Germany                   Berlin              3.6770     82790000   

                 gdp_per_cap  
Nation                       
Eire         69753.344482  
United Kingdom  39703.210176  
United States   59260.391198  
China            8831.168831  
India            1939.507095  
Germany         44413.576519  

Für jede Zeile in unserem Datenrahmen erstellen wir ein neues Etikett und setzen die Zeilendaten dem gesamten BIP auf, das durch die Bevölkerung des Landes geteilt ist, und multiplizieren Sie sie mit $ 1T für Tausende von Greenback.

Der vary() Funktion

Wir haben gesehen, wie wir benutzen können for Schleifen zur ITERATION über jede Sequenz- oder Datenstruktur. Aber was ist, wenn wir diese Sequenzen in einer bestimmten Reihenfolge oder für eine bestimmte Anzahl von Malen übernehmen möchten?

Dies kann mit Pythons eingebautem erreicht werden vary() Funktion. Abhängig davon, wie viele Argumente Sie an die Funktion übergeben, können Sie entscheiden, wo diese Reihe von Zahlen beginnen und enden, und wie groß der Unterschied zwischen einer und nächsten Zahl sein wird. Beachten Sie, dass ähnlich wie Hear die vary() Die Anzahl der Funktionen beginnt von 0 und nicht von 1.

Es gibt drei Möglichkeiten, wie wir anrufen können vary():

1. vary(cease)
2. vary(begin, cease)
3. vary(begin, cease, step)

vary(cease)

Wenn wir über eine Reihe von aufeinanderfolgenden Ganzzahlen iterieren wollen, die bei 0 beginnen und jede Zahl bis zu, aber bis zu, aber nicht einschließlichDie cease Wert, wir verwenden vary(cease).

for i in vary(3):
    print(i)

0
1
2

vary(begin, cease)

Hier wollen wir auch das Ende der Serie festlegen (cease) aber auch der Anfang (begin) sowie. Wir können die verwenden vary() Funktion zum Generieren einer Integer -Serie von A Zu B (Nicht einbezogen B) Verwenden vary(A, B).

for i in vary(1, 8):
    print(i)

1
2
3
4
5
6
7

vary(begin, cease, step)

Neben der Möglichkeit, das festzulegen begin Und cease Werte können wir auch die Differenz zwischen einer Zahl in der Sequenz und der nächsten einstellen a festlegen a step Wert beim Anruf vary(begin, cease, step). Der Customary step Der Wert ist 1, wenn keiner bereitgestellt wird.

for i in vary(3, 16, 3):
    print(i)

3
6
9
12
15

Beachten Sie, dass step Funktioniert auch für nicht numerische Sequenzen.

Wir können den Elementindex auch in einer Sequenz verwenden, um zu iterieren. Die Schlüsselidee besteht darin, zuerst die Länge der Liste zu berechnen und dann die Sequenz innerhalb des Bereichs dieser Länge zu iterieren. Schauen wir uns ein Beispiel an:

languages = ('Spanish', 'English',  'French', 'German', 'Irish', 'Chinese language')

for idx in vary(len(languages)):
   print('Language:', languages(idx))

Language: Spanish
Language: English
Language: French
Language: German
Language: Irish
Language: Chinese language

In unserem for Schleifen oben verwenden wir den Index der Variablen (idx) und Sprache die in Schlüsselwort und die vary() Funktion zum Erstellen einer Abfolge von Zahlen. Beachten Sie, dass wir auch die verwenden len() Funktion in diesem Fall, da die Liste nicht numerisch ist.

Für jede Iteration führen wir unsere aus print Stellungnahme. Additionally für jeden Index im Bereich len(languages)Wir möchten seine zugehörige Sprache drucken. Weil die Länge unserer languages Sequenz ist 6 (das ist der Wert, der len(langauges) bewertet), wir können die Aussage wie folgt umschreiben:

for idx in vary(6):
    print('Language:', languages(idx))

Language: Spanish
Language: English
Language: French
Language: German
Language: Irish
Language: Chinese language

Planung mit for Schleifen

Angenommen, wir wollen durch eine Sammlung iterieren und jedes Factor verwenden, um eine Nebenhandlung oder sogar für jede Spur in einem einzelnen Diagramm zu erzeugen. Nehmen wir zum Beispiel die Bevölkerung Iris -Datensatz (Erfahren Sie mehr über diese Daten) und etwas planen mit for Schleifen. Betrachten Sie die Grafik unten.

import pandas as pd
import matplotlib.pyplot as plt
%config InlineBackend.figure_format = 'retina'  # used to set determine format when working in an interactive pocket book

df = pd.read_csv('iris.csv')

fig, ax = plt.subplots()


ax.scatter(df('sepal_length'), df('sepal_width'))

ax.set_title('Iris Dataset')
ax.set_xlabel('sepal_length')
ax.set_ylabel('sepal_width')

Textual content(0,0.5,'sepal_width')

Oben haben wir jede Sepallänge im Vergleich zur Sepalbreite aufgetragen, aber wir können den Diagramm mehr Bedeutung geben, indem wir in jedem Datenpunkt der Artenklasse der einzelnen Blume färben. Eine Möglichkeit, dies zu tun for Schleifen und in die jeweilige Farbe übergeben.

colours = {'setosa':'r', 'versicolor':'g', 'virginica':'b'}


fig, ax = plt.subplots()


for i in vary(len(df('sepal_length'))):
    ax.scatter(df('sepal_length')(i), df('sepal_width')(i), colour=colours(df('species')(i)))


ax.set_title('Iris Dataset')
ax.set_xlabel('sepal_length')
ax.set_ylabel('sepal_width')

Textual content(0,0.5,'sepal_width')

Was ist, wenn wir die univariate Verteilung bestimmter Funktionen unseres Iris -Datensatzes visualisieren möchten? Wir können das mit tun plt.subplot()was eine einzelne Nebenhandlung innerhalb eines Rasters erzeugt, die Zahlen der Spalten und Zeilen, die wir festlegen können.

fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(8, 6))
fig.subplots_adjust(hspace=0.8)
fig.suptitle('Distributions of Iris Options')

for ax, characteristic, identify in zip(axes.flatten(), df.drop('species',axis=1).values.T, df.columns.values):
    ax.hist(characteristic, bins=len(np.distinctive(df.drop('species',axis=1).values.T(0))//2))
    ax.set(title=identify(:-4).higher(), xlabel='cm')

Ohne zu tief in die Matplotlib -Syntax zu tauchen, ist unten eine kurze Beschreibung jeder Hauptkomponente unseres Diagramms:

• plt.subplot( ) -Wird verwendet, um unser 2-mal-2-Gitter zu erstellen und die Gesamtgröße festzulegen.
• zip( ) – Dies ist eine eingebaute Python-Funktion, die es tremendous einfach macht, in gleichzeitiger Länge über mehrere iterable derselben Länge zu schalten.
• axes.flatten( )Wo flatten( ) ist eine Numpy Array -Methode – dies gibt eine abgeflachte Model unserer Arrays (Spalten) zurück.
• ax.set( ) – ermöglicht es uns, alle Attribute unserer festzulegen axes Objekt mit einer einzelnen Methode.

Zusätzliche Operationen

Verschachtelte Schleifen

Mit Python können wir eine Schleife in einer anderen Schleife verwenden. Dies beinhaltet eine äußere Schleife, die in seinen Befehlen eine innere Schleife hat.

Betrachten Sie die folgende Struktur:

for inner_sequence in sequence: 
    for factor in inner_sequence: 
        # code appearing on the element-level goes right here

Verschachtelt for Schleifen können nützlich sein, um Elemente in Hear zu iterieren, die aus Hear bestehen. In einer Liste, die aus Hear besteht, wenn wir nur eine beschäftigen for Schleife gibt das Programm jede interne Liste als Factor aus:

languages = (('Spanish', 'English',  'French', 'German'), 
             ('Python', 'Java', 'Javascript', 'C++'))

for row in languages:
    print(row)

('Spanish', 'English', 'French', 'German')
('Python', 'Java', 'Javascript', 'C++')

Um auf jedes einzelne Factor der internen Hear zuzugreifen (dh von, von row), wir definieren eine verschachtelte for Schleife über die Iterationsvariable der Außenschleife (Iterationrow):

for row in languages:
    print("------")
    for lang in row:
        print(lang)

------
Spanish
English
French
German
------
Python
Java
Javascript
C++

Oben die Außen for Die Schleife durchläuft durch die Hauptlistenlisten (die zwei Hear in diesem Beispiel enthält) und das Innere for Die Schleife durchläuft die einzelnen Hear selbst. Die äußere Schleife führt 2 Iterationen aus (für jede Unterliste) und bei jeder Iteration führen wir unsere innere Schleife aus, wodurch alle Elemente der jeweiligen Unterlisten gedruckt werden.

Dies sagt uns, dass die Kontrolle aus der äußersten Schleife bewegt, die innere Schleife durchquert und dann wieder zum Außenbereich zurück for Schleifen Sie fort, bis die Kontrolle den gesamten Bereich abdeckt, der in diesem Fall zweimal beträgt.

Fortsetzung und Brechen for Schleifen

Schleifensteuerungsanweisungen ändern die Ausführung von a for Schleife aus seiner normalen Sequenz.

Was ist, wenn wir eine bestimmte Sprache in unserer inneren Schleife herausfiltern möchten? Wir können a verwenden proceed Aussagen dazu, mit der wir einen bestimmten Teil unserer Schleife überspringen können, wenn ein externer Zustand ausgelöst wird.

for x in languages:
    print("------")
    for lang in x:
        if lang == "German":
            proceed
        print(lang)

------
Spanish
English
French
------
Python
Java
Javascript
C++

In unserer obigen Schleife in der inneren Schleife überspringen wir diese Iteration nur und fahren mit dem Relaxation der Schleife fort. Beachten Sie, dass die Schleife nicht beendet wird, wenn sie in a eingeht proceed Stellungnahme.

Schauen wir uns ein numerisches Beispiel an, um zu sehen, wie wir verwenden können proceed Um bestimmte Werte in einer Schleife zu überspringen:

from math import sqrt
quantity = 0

for i in vary(10):
   quantity = i ** 2

   if i % 2 == 0:
      proceed    

   print(str(spherical(sqrt(quantity))) + ' squared is the same as ' + str(quantity))

1 squared is the same as 1
3 squared is the same as 9
5 squared is the same as 25
7 squared is the same as 49
9 squared is the same as 81

Hier haben wir additionally eine Schleife definiert, die über alle Zahlen 0 bis 9 iteriert und jede Zahl quadriert. In unserer Schleife prüfen wir bei jeder Iteration, ob die Zahl durch 2 teilbar ist. An diesem Punkt wird die Schleife weiter ausgeführt, und überspringt die Iteration, wenn i ist eine gleichmäßige Zahl.

Was ist mit a break Stellungnahme? Dies ermöglicht es uns, eine Schleife vollständig zu verlassen, wenn ein externer Zustand erfüllt ist. Lassen Sie uns eine einfache Demonstration sehen, wie dies funktioniert, wie dies oben verwendet wird wie oben:

quantity = 0

for i in vary(10):
   quantity = i ** 2

   if i == 7:
      break

   print(str(spherical(sqrt(quantity))) + ' squared is the same as ' + str(quantity))

0 squared is the same as 0
1 squared is the same as 1
2 squared is the same as 4
3 squared is the same as 9
4 squared is the same as 16
5 squared is the same as 25
6 squared is the same as 36

Im obigen Beispiel unsere if Aussage zeigt die Bedingung, dass wenn unsere Variable i Bewertet bis 7, unsere Schleife wird brechen, sodass unsere Schleife über Ganzzahlen 0 bis 6 iteriert, bevor sie vollständig aus der Schleife fallen.

Auf der Suche nach mehr? Hier sind einige zusätzliche Ressourcen, die nützlich sein könnten:

Nächste Schritte

In diesem Tutorial haben wir einige fortgeschrittenere Anwendungen von erfahren für Schleifenund wie sie in typischen Python -Datenwissenschaftsworkflows verwendet werden können.

Wir haben gelernt, wie man verschiedene Arten von Datenstrukturen iteriert und wie Loops mit Pandas-Datenrahmen und Matplotlib verwendet werden können, um programmgesteuert mehrere Spuren oder Unterhandlungen zu erstellen.

Schließlich haben wir uns einige fortgeschrittenere Techniken angesehen, die uns mehr Kontrolle über den Betrieb und die Ausführung unserer für Schleifen geben.

Wenn Sie mehr über dieses Thema erfahren möchten, lesen Sie die DataQuests Datenwissenschaftler in Python Karriereweg, der Ihnen dabei hilft, in wenigen Monaten berufsfertig zu werden.

Generative KI wurde häufig wegen seiner Unfähigkeit, effektiv zu argumentieren, kritisiert, insbesondere in Szenarien, die präzise und deterministische Ergebnisse erfordern. Es hat sich als sehr schwierig erwiesen, den nächsten Token kaum vorherzusagen, wenn der nächste Token so genau sein muss wie eine einzelne Choice. Beispielsweise kann das Schreiben eines Aufsatzes tausend Formen annehmen und dennoch akzeptabel sein, aber die Lösung einer quadratischen Gleichung muss eine bestimmte endgültige Antwort liefern. Genau dieses Drawback hat Alibabas KI-Abteilung MarcoPolo dazu veranlasst, den bahnbrechenden Marco-o1 zu entwickeln großes Sprachmodell (LLM), der die Messlatte für komplexe Denkaufgaben höher legt. Dieses revolutionary Modell zeichnet sich in verschiedenen Bereichen wie Mathematik, Physik, Codierung und mehrsprachigen Anwendungen aus und bietet reale Lösungen für konventionelle und offene Herausforderungen.

Lernziele

• Das Konzept und die Bedeutung von Massive Reasoning Fashions (LRMs).
• Die wichtigsten technologischen Innovationen von Marco-o1 und wie sie es auszeichnen.
• Benchmarks und Ergebnisse unterstreichen seine fortschrittlichen Fähigkeiten.
• Praktische Anwendungen, insbesondere bei der mehrsprachigen Übersetzung.
• Einblicke in Transparenz, Herausforderungen und Zukunftspläne für Marco-o1.

Dieser Artikel wurde im Rahmen der veröffentlicht Knowledge Science-Blogathon.

Kerninnovationen hinter Marco-o1

Marco-o1 unterscheidet sich von anderen Modellen durch die Integration einer Kombination fortschrittlicher Techniken zur Optimierung von Argumentation, Entscheidungsfindung und Genauigkeit. Dies sind einige Dinge, die herkömmliche LLMs nicht leisten.

Hier ist ein Screenshot, der die beliebte Zählung des Buchstabens r im Wort „Erdbeere“ zeigt.

Chain-of-Thought (CoT) Feinabstimmung

Dieser Ansatz ermöglicht es dem Modell, Schritt für Schritt zu argumentieren und nachzuahmen, wie Menschen komplexe Probleme lösen. Die Feinabstimmung mit Open-Supply-CoT-Datensätzen und Alibabas proprietären synthetischen Datensätzen hat Marco-o1s Fähigkeit, komplizierte Aufgaben zu bewältigen, verbessert.

Monte-Carlo-Baumsuche (MCTS)

Mit dieser Methode kann das Modell mehrere Argumentationspfade erkunden, von umfassenden Strategien bis hin zu detaillierten Minischritten (z. B. die gleichzeitige Generierung von 32 oder 64 Token). MCTS erweitert den Lösungsraum und ermöglicht eine fundiertere Entscheidungsfindung.

Reflexionsmechanismen

Ein herausragendes Merkmal von Marco-o1 ist seine Fähigkeit zur Selbstreflexion. Das Modell bewertet seine Argumentationsprozesse, identifiziert Ungenauigkeiten und iteriert seine Ergebnisse, um bessere Ergebnisse zu erzielen.

Mehrsprachige Beherrschung

Marco-o1 zeichnet sich durch hervorragende Übersetzungen aus, da es mit beispielloser Leichtigkeit kulturelle Nuancen, idiomatische Ausdrücke und umgangssprachliche Ausdrücke handhabt, was es zu einem leistungsstarken Werkzeug für die globale Kommunikation macht.

Einige beeindruckende Benchmarks und Ergebnisse von Marco-o1

Die Fähigkeiten von Marco-o1 spiegeln sich in seinen beeindruckenden Leistungskennzahlen wider. Es hat erhebliche Verbesserungen bei Argumentations- und Übersetzungsaufgaben gezeigt:

• +6,17 % Genauigkeit beim englischen MGSM-Datensatz.
• +5,60 % Genauigkeit beim chinesischen MGSM-Datensatz.
• Außergewöhnlicher Umgang mit mehrsprachigen Übersetzungen, präzise Erfassung kultureller Feinheiten und umgangssprachlicher Phrasen.

Diese Ergebnisse stellen einen bedeutenden Fortschritt in der Fähigkeit des Modells dar, Sprache und Logik effektiv zu kombinieren.

Anwendungen: Mehrsprachige Übersetzung und darüber hinaus

Marco-o1 ist Vorreiter beim Einsatz von Massive Reasoning Fashions (LRM) in der maschinellen Übersetzung. Die mehrsprachigen Fähigkeiten des Modells gehen über die bloße Übersetzung hinaus, indem sie Skalierungsgesetze zum Zeitpunkt der Inferenz untersuchen, was es zu einem robusten Werkzeug für die globale Kommunikation macht. Es leistet Pionierarbeit beim Einsatz von LRMs in verschiedenen realen Szenarien:

• Mehrsprachige Übersetzung: Über grundlegende Übersetzungen hinaus nutzt es Skalierungsgesetze während der Inferenz, um die sprachliche Präzision und das Kontextbewusstsein zu verbessern.
• Kodierung und wissenschaftliche Forschung: Seine klaren Argumentationspfade machen es zu einem zuverlässigen Werkzeug zur Lösung von Programmierproblemen und zur Unterstützung wissenschaftlicher Entdeckungen.
• Globale Problemlösung: Ob im Bildungswesen, im Gesundheitswesen oder in der Wirtschaft, das Modell passt sich nahtlos an Aufgaben an, die Logik und Argumentation erfordern.

Transparenz und Open Entry

Alibaba hat mit der Veröffentlichung von Marco-o1 und seinen Datensätzen auf GitHub einen mutigen Schritt getan und so Zusammenarbeit und Innovation gefördert. Entwickler und Forscher haben Zugriff auf:

• Umfangreiche Dokumentation.
• Implementierungsleitfäden.
• Beispielskripte für die Bereitstellung, einschließlich der Integration mit Frameworks wie FastAPI mithilfe von vLLM (die wir in diesem Artikel sehen werden).

Diese Offenheit ermöglicht es der KI-Neighborhood, die Fähigkeiten von Marco-o1 für breitere Anwendungen zu verfeinern und zu erweitern.

Warum Marco-o1 wichtig ist

Die Enthüllung von Marco-o1 markiert einen entscheidenden Second in der KI-Entwicklung. Seine Fähigkeit, komplexe Probleme zu lösen, sich an mehrsprachige Kontexte anzupassen und sich selbst zu reflektieren, macht es an die Spitze der KI der nächsten Technology. Ob es darum geht, wissenschaftliche Herausforderungen anzugehen, differenzierte Texte zu übersetzen oder offene Fragen zu beantworten, Marco-o1 ist bereit, die Landschaft der KI-Anwendungen neu zu gestalten.

Für Forscher und Entwickler ist Marco-o1 nicht nur ein Werkzeug, sondern eine Einladung zur Zusammenarbeit bei der Neudefinition dessen, was KI leisten kann. Indem Marco-o1 die Lücke zwischen Argumentation und Kreativität schließt, setzt er einen neuen Normal für die Zukunft der künstlichen Intelligenz.

Praktisch: Marco-o1 mithilfe von Code erkunden

Das offizielle Github-Repo enthält schöne Beispiele, die Ihnen helfen, das Modell mit verschiedenen Anwendungsfällen zu testen. Weitere Beispiele finden Sie hier https://github.com/AIDC-AI/Marco-o1/tree/most important/examples

from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
import torch
from vllm import LLM, SamplingParams
from transformers import AutoTokenizer

# Initialize FastAPI app
app = FastAPI()

# Outline a request mannequin utilizing Pydantic for validation
class ChatRequest(BaseModel):
    user_input: str  # The consumer's enter textual content
    historical past: record  # An inventory to retailer chat historical past

# Variables for mannequin and tokenizer
tokenizer = None
mannequin = None

@app.on_event("startup")
def load_model_and_tokenizer():
    """
    Load the mannequin and tokenizer as soon as throughout startup.
    This ensures sources are initialized solely as soon as, bettering effectivity.
    """
    international tokenizer, mannequin
    path = "AIDC-AI/Marco-o1"  # Path to the Marco-o1 mannequin
    tokenizer = AutoTokenizer.from_pretrained(path, trust_remote_code=True)
    mannequin = LLM(mannequin=path, tensor_parallel_size=4)  # Parallelize mannequin processing

def generate_response_stream(mannequin, textual content, max_new_tokens=4096):
    """
    Generate responses in a streaming vogue.
    :param mannequin: The language mannequin to make use of.
    :param textual content: The enter immediate.
    :param max_new_tokens: Most variety of tokens to generate.
    """
    new_output=""  # Initialize the generated textual content
    sampling_params = SamplingParams(
        max_tokens=1,  # Generate one token at a time for streaming
        temperature=0,  # Deterministic technology
        top_p=0.9  # Controls variety in token choice
    )
    with torch.inference_mode():  # Allow environment friendly inference mode
        for _ in vary(max_new_tokens):  # Generate tokens as much as the restrict
            outputs = mannequin.generate(
                (f'{textual content}{new_output}'),  # Concatenate enter and present output
                sampling_params=sampling_params,
                use_tqdm=False  # Disable progress bar for cleaner streaming
            )
            next_token = outputs(0).outputs(0).textual content  # Get the subsequent token
            new_output += next_token  # Append token to the output
            yield next_token  # Yield the token for streaming

            if new_output.endswith('</Output>'):  # Cease if the top marker is discovered
                break

@app.submit("/chat/")
async def chat(request: ChatRequest):
    """
    Deal with chat interactions by way of POST requests.
    :param request: Accommodates consumer enter and chat historical past.
    :return: Streamed response or error message.
    """
    # Validate consumer enter
    if not request.user_input:
        increase HTTPException(status_code=400, element="Enter can't be empty.")

    # Deal with exit instructions
    if request.user_input.decrease() in ('q', 'stop'):
        return {"response": "Exiting chat."}

    # Deal with clear command to reset chat historical past
    if request.user_input.decrease() == 'c':
        request.historical past.clear()
        return {"response": "Clearing chat historical past."}

    # Replace historical past with consumer enter
    request.historical past.append({"function": "consumer", "content material": request.user_input})

    # Create the mannequin immediate with historical past
    textual content = tokenizer.apply_chat_template(request.historical past, tokenize=False, add_generation_prompt=True)

    # Stream the generated response
    response_stream = generate_response_stream(mannequin, textual content)

    # Return the streamed response
    return StreamingResponse(response_stream, media_type="textual content/plain")

Der obige Code stammt aus dem offiziellen Repo. Wenn das Skript jedoch abstürzt, bevor es reagiert, liegt möglicherweise eine Diskrepanz zwischen der Speicherkapazität Ihrer GPU und den Anforderungen des Modells vor. Dies ist häufig der Fall, wenn Sie mit großen Modellen arbeiten, die mehr VRAM benötigen, als auf Ihrer GPU verfügbar ist. Da es sich um einen Fastapi-Code handelt, ist es sinnvoller, ihn auf Ihrem Laptop auszuführen, der möglicherweise nicht über einen geeigneten VRAM verfügt.

Ich habe versucht, ngrok zu verwenden, um die API mithilfe von Google Colab verfügbar zu machen, damit Sie dort die kostenlose GPU genießen können, die Sie in diesem Artikel-Repo finden: https://github.com/inuwamobarak/largeReasoningModels/tree/most important/Marco-01

Wrapper-Skript mit GPU

Um Ihnen beim Testen der Leistung dieses Modells zu helfen, finden Sie hier ein Wrapper-Skript, mit dem Sie es unterwegs in Google Colab mithilfe einer GPU ausführen können. Beachten Sie, dass ich Float 16 hinzugefügt habe und es über 13 GB GPU verbraucht.

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

Wrapper-Skript mit 16 Float-Genauigkeit:

class ModelWrapper:
    def __init__(self, model_name):
        self.system = torch.system("cuda" if torch.cuda.is_available() else "cpu")
        # Load mannequin with half-precision if supported, or use device_map for environment friendly placement
        strive:
            self.mannequin = AutoModelForCausalLM.from_pretrained(
                model_name, 
                torch_dtype=torch.float16 if torch.cuda.is_available() else None, 
                device_map="auto"
            )
        besides Exception as e:
            print(f"Error loading mannequin: {e}")
            increase
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)

        # Allow gradient checkpointing for big fashions
        self.mannequin.gradient_checkpointing_enable()

        # Debug: Test if mannequin is on GPU
        print(f"Mannequin loaded to system: {subsequent(self.mannequin.parameters()).system}")

    def generate_text(self, immediate, max_length=100, num_return_sequences=1):
        inputs = self.tokenizer(immediate, return_tensors="pt")
        inputs = {key: worth.to(self.system) for key, worth in inputs.objects()}  # Transfer inputs to GPU
        outputs = self.mannequin.generate(
            **inputs, max_length=max_length, num_return_sequences=num_return_sequences
        )
        generated_texts = (
            self.tokenizer.decode(output, skip_special_tokens=True) for output in outputs
        )
        return generated_texts

Beispiel eins

# Instance utilization
if __name__ == "__main__":
    model_name = "AIDC-AI/Marco-o1"
    model_wrapper = ModelWrapper(model_name)

    immediate = "As soon as upon a time, in a land far, far-off,"
    generated_texts = model_wrapper.generate_text(immediate, max_length=50, num_return_sequences=1)

    for i, textual content in enumerate(generated_texts):
        print(f"Generated Textual content {i+1}:n{textual content}n")

Mannequin loaded to system: cuda:0 Generated Textual content 1: As soon as upon a time, in a land far, far-off, there lived a king who was very keen on his backyard. He had an exquisite backyard with many flowers and bushes. Someday, he determined to plant some new bushes in his backyard. 

Beispiel zwei

immediate = "What number of S's are there in Mississippi"
generated_texts = model_wrapper.generate_text(immediate, num_return_sequences=1)

for i, textual content in enumerate(generated_texts):
    print(f"Generated Textual content {i+1}:n{textual content}n")

Generated Textual content 1:
What number of S's are there in Mississippi? To find out what number of 'S's are within the phrase "Mississippi," let's analyze the phrase step-by-step.

First, let's write out the phrase:
M-I-S-S-I-S-S-I-P-P-I

Now, let's establish every letter and rely the 'S's:
1. The primary letter is M.
2. The second letter is I.
3. The third letter is S.
4. The fourth letter is S.
5. The fifth letter is I.
6. The sixth letter is S.
7. The seventh letter is S.
8. The eighth letter is I.
9. The ninth letter is P.
10. The tenth letter is P.
11. The eleventh letter is I.

From this evaluation, we will see that the letters 'S' seem at positions 3, 4, 6, 7, and 11. That is a complete of 5 'S's.

To double-check, let's rely them once more:
- Place 3: S
- Place 4: S
- Place 6: S
- Place 7: S
- Place 11: S

Sure, there are certainly 5 'S's within the phrase "Mississippi."

Due to this fact, the variety of 'S's in Mississippi is boxed{4}. Wait, that is incorrect based mostly on the earlier rely. Let me recount fastidiously.

Upon re-examining:
1. M
2. I
3. S
4. S
5. I
6. S
7. S
8. I
9. P
10. P
11. I

Counting the 'S's:
- Place 3: S
- Place 4: S
- Place 6: S
- Place 7: S

That is 4 'S's. It appears I initially miscounted the final 'S' at place 11 as an 'I.' Due to this fact, the right variety of 'S's in Mississippi is boxed{4}. 

Nevertheless, to make sure accuracy, let's use one other technique. The phrase "Mississippi" has 11 letters in complete. The vowels are I, I, I, and I (4 'I's), and the consonants are M, S, S, S, S, P, P. Counting the 'S's among the many consonants offers us 4 'S's.

Sie werden feststellen, dass das Modell versucht, zu überlegen, wie es die ihm gestellten Probleme löst. Dies ist der Unterschied zwischen LRM und früheren LLMs.

Herausforderungen und Zukunftspläne

Während Marco-o1 neue Maßstäbe gesetzt hat, erkennt das Entwicklungsteam Raum für Wachstum. Die Argumentationsfähigkeiten des Modells sind strong, aber noch nicht vollständig optimiert. Um dieses Drawback anzugehen, plant Alibaba Folgendes zu integrieren:

• Final result Reward Modeling (ORM) und Course of Reward Modeling (PRM) zur Verfeinerung der Entscheidungsfindung.
• Verstärkungslerntechniken zur weiteren Verbesserung der Problemlösung.

Diese Bemühungen unterstreichen das Engagement von MarcoPolo für die Weiterentwicklung der Denkfähigkeiten der KI.

Abschluss

Marco-o1 stellt einen entscheidenden Fortschritt in der künstlichen Intelligenz dar, der kritische Einschränkungen traditioneller Sprachmodelle durch die Integration robuster Argumentations- und Entscheidungsfähigkeiten angeht. Seine bahnbrechenden Innovationen – die, wie wir gesehen haben, das Denken in der Gedankenkette, die Monte-Carlo-Baumsuche, die Selbstreflexion und die Beherrschung mehrerer Sprachen umfassen – demonstrieren einen neuen Normal für die Lösung komplexer, realer Probleme. Mit beeindruckenden Benchmarks und offenem Zugang zu seiner Architektur bietet Marco-o1 nicht nur branchenübergreifende transformative Lösungen, sondern lädt auch die globale KI-Neighborhood ein, zusammenzuarbeiten, um die Grenzen des Möglichen zu erweitern. Wir können sagen, dass Marco-o1 die Zukunft argumentationsgesteuerter Sprachmodelle veranschaulicht.

Wichtige Erkenntnisse

• Marco-o1 geht über die Token-Vorhersage hinaus, indem es Techniken wie Chain-of-Thought und Monte-Carlo-Baumsuche zur erweiterten Problemlösung einbezieht.
• Die Fähigkeit des Modells, seine Argumentation zu bewerten und zu verfeinern, zeichnet es aus und gewährleistet eine höhere Genauigkeit und Anpassungsfähigkeit.
• Unübertroffene Übersetzungsfähigkeiten ermöglichen es Marco-o1, kulturelle Nuancen und idiomatische Ausdrücke präzise zu verarbeiten.
• Durch die Veröffentlichung der Datensätze und Implementierungshandbücher von Marco-o1 auf GitHub fördert Alibaba die Zusammenarbeit und fördert weitere Fortschritte in der KI-Forschung.

Referenzlinks

Häufig gestellte Fragen

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Lernen Sie Gemini Superior kennen. Dabei handelt es sich um eine Premiumfunktion, die in Googles KI-zentriertem Google One AI Premium-Plan eingebettet ist und die Standardfunktionen der Gemini-Dienste erweitern soll.

Was ist Gemini Superior?

Gemini Superior ist eine hochrangige Funktion im kostenpflichtigen Tarif Google One AI Premium. Dieses Angebot erweitert die Fähigkeiten der Standarddienste von Gemini, indem es erweiterte Funktionen in Google-Apps wie Gmail und Docs integriert und neben anderen Vorteilen beachtliche 2 TB Speicherplatz bietet. Gemini Superior ist besonders auf Aufgaben ausgerichtet, die ein hohes Maß an Komplexität erfordern, wie etwa Codierung, logisches Denken, das Befolgen nuancierter Anweisungen und kreative Zusammenarbeit, und zeichnet sich durch seine robusten KI-Instruments aus.

Im Kern Gemini Superior enthält Gemini 1.5 Professional, das über ein Kontextfenster mit 1 Million Token verfügt, mit dem Benutzer tief in Dokumente eintauchen und Inhalte analysieren und verstehen können, die bis zu 1.500 Seiten umfassen können. Diese Funktion ist besonders nützlich für Fachleute und Kreative, die mit umfangreichen Dokumenten arbeiten müssen und detaillierte Einblicke und Zusammenfassungen benötigen.

Benutzer können auf Gemini Superior zugreifen über Gemini-Net-App und cell Apps, mit Verfügbarkeit in über 45 Sprachen und in mehr als 150 Ländern. Es ist jedoch wichtig zu beachten, dass Gemini Superior nicht für Benutzer unter 18 Jahren oder für Arbeits- oder Schulkonten verfügbar ist, es sei denn, dies wurde ausdrücklich von einem Administrator aktiviert. Für diejenigen, die dazu berechtigt sind, kann ein Improve auf Gemini Superior ihre Produktivität und kreativen Fähigkeiten erheblich steigern und es zu einem leistungsstarken Werkzeug im Arsenal jeder technisch versierten Individual machen.

Erweiterte Funktionen von Gemini

Gemini Superior wurde entwickelt, um die Fähigkeiten der KI-Instruments von Google zu verbessern und bietet eine Reihe von Funktionen, die hochkomplexe Aufgaben in verschiedenen Anwendungen bewältigen. Hier ist eine Übersicht der wichtigsten Funktionen von Gemini Superior:

• Erweiterte KI-Funktionen: Gemini Superior nutzt die Leistung von Gemini 1.5 Professional, das ein Kontextfenster von bis zu 1 Million Token verwalten kann. Dies ermöglicht eine gründliche Analyse und das Verständnis großer Dokumente mit einer Länge von bis zu 1.500 Seiten.
• Integration über Google-Apps hinweg: Benutzer können von der Integration der Gemini-Funktionen in beliebte Google-Apps wie Gmail und Google Docs profitieren und so die Produktivität und die Zusammenarbeit innerhalb dieser Plattformen verbessern.
• Umfangreicher Speicher: Als Teil des Google One AI Premium-Plans umfasst Gemini Superior 2 TB Cloud-Speicher und bietet ausreichend Platz zum Speichern großer Dateien, umfangreicher Dokumente und anderer Daten.
• Datei-Uploads für vertiefte Einblicke: Mit der Gemini-Net-App können Benutzer Dateien direkt zur detaillierten Analyse hochladen. Sie erhalten Antworten, Zusammenfassungen und Einblicke in den Inhalt, wodurch ihr Verständnis und ihre Entscheidungsfähigkeit weiter verbessert werden.
• Globale Erreichbarkeit: Gemini Superior ist in mehr als 45 Sprachen und über 150 Ländern verfügbar und steht einer breiten Palette von Benutzern weltweit zur Verfügung. Eine Ausweitung auf noch mehr Sprachen ist geplant.
• Einschränkungen und Zugriff: Es ist wichtig zu beachten, dass Gemini Superior für Benutzer unter 18 Jahren oder für Arbeits- oder Schulkonten nicht verfügbar ist, es sei denn, der Zugriff wird von einem Administrator aktiviert. Dadurch wird sichergestellt, dass die leistungsstarken Funktionen des Instruments in geeigneten und autorisierten Kontexten verwendet werden.

Wie verwende ich Gemini Superior?

Improve auf Gemini Superior:

• Navigieren Sie zunächst zur Gemini-Web site unter gemini.google.com.
• Klicken oder tippen Sie oben auf der Seite auf das „Menü“ und wählen Sie aus den Optionen „Improve auf Gemini Superior“ aus.
• Befolgen Sie die Anweisungen auf dem Bildschirm, um den Google One AI Premium-Plan zu abonnieren, der Gemini Superior beinhaltet. In diesem Schritt müssen Sie eine Zahlungsmethode auswählen oder angeben.

Zugriff auf erweiterte Funktionen von Gemini:

• Nach dem Improve können Sie entweder über die Gemini-Net-App oder die cell App auf Gemini Superior zugreifen.
• Wählen Sie in der Gemini-Net-App oben auf dem Bildschirm „Gemini“ oder „Gemini Superior“ aus, um zwischen den Commonplace- und erweiterten Funktionen zu wechseln.
• Stellen Sie als mobiler Benutzer sicher, dass die Gemini-App aktualisiert ist, und prüfen Sie, ob Gemini Superior angezeigt wird. Wenn es nicht angezeigt wird, ist möglicherweise ein Neustart oder eine Neuinstallation erforderlich.

Verwenden von Gemini 1.5 Professional:

• Mit Gemini Superior erhalten Sie Zugriff auf Gemini 1.5 Professional, das ein Kontextfenster mit 1 Million Token enthält. Diese Funktion ermöglicht eine detaillierte Analyse großer Dokumente.
• Laden Sie Dokumente in die Gemini-Net-App hoch, um mit der Analyse zu beginnen. Sie können umfassende Einblicke, Zusammenfassungen und Antworten zu Ihren Inhalten erhalten.

Integration mit Google Apps:

• Gemini Superior lässt sich nahtlos in andere Google-Anwendungen wie Gmail und Docs integrieren. Durch diese Integration können Sie erweiterte KI-Funktionen direkt in diesen Apps nutzen und so die Produktivität und Zusammenarbeit verbessern.

Verwalten Sie Ihr Abonnement:

• Sie können Ihre Abonnementeinstellungen verwalten oder ändern, indem Sie zu gemini.google.com gehen, zu „Einstellungen“ und dann zu „Abonnement verwalten“ navigieren.
• Hier können Sie Ihren Mitgliedschaftsplan ändern oder Ihr Abonnement bei Bedarf kündigen.

Erweiterte Preispläne von Gemini

In den USA kostet der Google One AI Premium-Plan, der Gemini Superior beinhaltet, 19,99 $ professional Monat. Dieser Plan ist auf Benutzer zugeschnitten, die erweiterte KI-Funktionen für verschiedene Google-Anwendungen, darunter Gmail und Google Docs, suchen. Abonnenten erhalten 2 TB Cloud-Speicher, der für Google Drive, Fotos und Gmail verwendet werden kann. Dieser umfangreiche Speicherplatz ist superb für Einzelpersonen und Unternehmen, die große Datenmengen verarbeiten.

Der Plan umfasst Gemini Superior mit seinem leistungsstarken 1.5 Professional-Modell. Dieses fortschrittliche KI-Instrument ist für komplexe Aufgaben wie tiefgehende Dokumentenanalyse, Codierung, logisches Denken und kreative Zusammenarbeit konzipiert und steigert Produktivität und Effizienz. Gemini Superior lässt sich nahtlos in Google-Dienste integrieren, sodass Benutzer seine Funktionen direkt in Apps wie Gmail und Docs nutzen können, um einen optimierten Arbeitsablauf zu erreichen.

Der Plan kann mit bis zu fünf anderen Benutzern geteilt werden, was ihn zu einer kostengünstigen Lösung für Familien oder kleine Groups macht. Diese Freigabefunktion erweitert alle Vorteile des AI Premium-Plans auf jedes Mitglied, einschließlich des vollen Speicherkontingents von 2 TB. Abonnenten genießen außerdem Premiumfunktionen von Google Workspace, die je nach aktuellem Angebot von Google erweiterte Bearbeitungsfunktionen, erweiterte Sicherheitseinstellungen und mehr umfassen können.

---

Bildnachweis: Google