In diesem Tutorial untersuchen wir, wie man Agentensysteme aufbaut, die über eine einzelne Interaktion hinausdenken, indem Speicher als Kernfunktion genutzt wird. Wir gehen durch, wie wir das episodische Gedächtnis zum Speichern von Erfahrungen und das semantische Gedächtnis zum Erfassen langfristiger Muster entwerfen, sodass der Agent sein Verhalten über mehrere Sitzungen hinweg weiterentwickeln kann. Während wir planen, handeln, überarbeiten und reflektieren, beobachten wir, wie sich der Agent allmählich an die Präferenzen des Benutzers anpasst und autonomer wird. Am Ende verstehen wir, wie gedächtnisgesteuertes Denken uns hilft, Agenten zu schaffen, die sich bei jeder Interaktion kontextbezogener, konsistenter und intelligenter anfühlen. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

import numpy as np
from collections import defaultdict
import json
from datetime import datetime
import pickle


class EpisodicMemory:
   def __init__(self, capability=100):
       self.capability = capability
       self.episodes = ()
      
   def retailer(self, state, motion, consequence, timestamp=None):
       if timestamp is None:
           timestamp = datetime.now().isoformat()
       episode = {
           'state': state,
           'motion': motion,
           'consequence': consequence,
           'timestamp': timestamp,
           'embedding': self._embed(state, motion, consequence)
       }
       self.episodes.append(episode)
       if len(self.episodes) > self.capability:
           self.episodes.pop(0)
  
   def _embed(self, state, motion, consequence):
       textual content = f"{state} {motion} {consequence}".decrease()
       return hash(textual content) % 10000
  
   def retrieve_similar(self, query_state, ok=3):
       if not self.episodes:
           return ()
       query_emb = self._embed(query_state, "", "")
       scores = ((abs(ep('embedding') - query_emb), ep) for ep in self.episodes)
       scores.kind(key=lambda x: x(0))
       return (ep for _, ep in scores(:ok))
  
   def get_recent(self, n=5):
       return self.episodes(-n:)


class SemanticMemory:
   def __init__(self):
       self.preferences = defaultdict(float)
       self.patterns = defaultdict(checklist)
       self.success_rates = defaultdict(lambda: {'success': 0, 'whole': 0})
      
   def update_preference(self, key, worth, weight=1.0):
       self.preferences(key) = 0.9 * self.preferences(key) + 0.1 * weight * worth
  
   def record_pattern(self, context, motion, success):
       pattern_key = f"{context}_{motion}"
       self.patterns(context).append((motion, success))
       self.success_rates(pattern_key)('whole') += 1
       if success:
           self.success_rates(pattern_key)('success') += 1
  
   def get_best_action(self, context):
       if context not in self.patterns:
           return None
       action_scores = defaultdict(lambda: {'success': 0, 'whole': 0})
       for motion, success in self.patterns(context):
           action_scores(motion)('whole') += 1
           if success:
               action_scores(motion)('success') += 1
       best_action = max(action_scores.gadgets(), key=lambda x: x(1)('success') / max(x(1)('whole'), 1))
       return best_action(0) if best_action(1)('whole') > 0 else None
  
   def get_preference(self, key):
       return self.preferences.get(key, 0.0)

Wir definieren die Kernspeicherstrukturen, auf die sich unser Agent verlässt. Wir bauen ein episodisches Gedächtnis auf, um spezifische Erfahrungen zu erfassen, und ein semantisches Gedächtnis, um Muster im Laufe der Zeit zu verallgemeinern. Indem wir diese Grundlagen schaffen, bereiten wir den Agenten darauf vor, aus Interaktionen zu lernen, so wie es Menschen tun. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class MemoryAgent:
   def __init__(self):
       self.episodic_memory = EpisodicMemory(capability=50)
       self.semantic_memory = SemanticMemory()
       self.current_plan = ()
       self.session_count = 0
      
   def understand(self, user_input):
       user_input = user_input.decrease()
       if any(phrase in user_input for phrase in ('suggest', 'recommend', 'what ought to')):
           intent="advice"
       elif any(phrase in user_input for phrase in ('bear in mind', 'favor', 'like', 'favourite')):
           intent="preference_update"
       elif any(phrase in user_input for phrase in ('do', 'full', 'end', 'activity')):
           intent="task_execution"
       else:
           intent="dialog"
       return {'intent': intent, 'uncooked': user_input}
  
   def plan(self, state):
       intent = state('intent')
       user_input = state('uncooked')
       similar_episodes = self.episodic_memory.retrieve_similar(user_input, ok=3)
       plan = ()
       if intent == 'advice':
           genre_prefs = {ok: v for ok, v in self.semantic_memory.preferences.gadgets() if 'genre_' in ok}
           if genre_prefs:
               best_genre = max(genre_prefs.gadgets(), key=lambda x: x(1))(0)
               plan.append(('suggest', best_genre.exchange('genre_', '')))
           else:
               plan.append(('suggest', 'normal'))
       elif intent == 'preference_update':
           genres = ('sci-fi', 'fantasy', 'thriller', 'romance', 'thriller')
           detected_genre = subsequent((g for g in genres if g in user_input), None)
           if detected_genre:
               plan.append(('update_preference', detected_genre))
       elif intent == 'task_execution':
           best_action = self.semantic_memory.get_best_action('activity')
           if best_action:
               plan.append(('execute', best_action))
           else:
               plan.append(('execute', 'default'))
       self.current_plan = plan
       return plan

Wir konstruieren die Wahrnehmungs- und Planungssysteme des Agenten. Wir verarbeiten die Eingaben des Benutzers, erkennen Absichten und erstellen Pläne, indem wir die zuvor gebildeten Erinnerungen nutzen. Wir beginnen zu gestalten, wie der Agent seine nächsten Aktionen begründet und entscheidet. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

 def act(self, motion):
       action_type, param = motion
       if action_type == 'suggest':
           if param == 'normal':
               return f"Let me be taught your preferences first! What genres do you get pleasure from?"
           return f"Based mostly in your preferences, I like to recommend exploring {param}!"
       elif action_type == 'update_preference':
           self.semantic_memory.update_preference(f'genre_{param}', 1.0, weight=1.0)
           return f"Received it! I am going to bear in mind you get pleasure from {param}."
       elif action_type == 'execute':
           return f"Executing activity with technique: {param}"
       return "Motion accomplished"
  
   def revise_plan(self, suggestions):
       if 'no' in suggestions.decrease() or 'incorrect' in suggestions.decrease():
           if self.current_plan:
               action_type, param = self.current_plan(0)
               if action_type == 'suggest':
                   genre_prefs = sorted(
                       ((ok, v) for ok, v in self.semantic_memory.preferences.gadgets() if 'genre_' in ok),
                       key=lambda x: x(1),
                       reverse=True
                   )
                   if len(genre_prefs) > 1:
                       new_genre = genre_prefs(1)(0).exchange('genre_', '')
                       self.current_plan = (('suggest', new_genre))
                       return True
       return False
  
   def replicate(self, state, motion, consequence, success):
       self.episodic_memory.retailer(state('uncooked'), str(motion), consequence)
       self.semantic_memory.record_pattern(state('intent'), str(motion), success)

Wir definieren, wie der Agent Aktionen ausführt, seine Entscheidungen revidiert, wenn das Suggestions den Erwartungen widerspricht, und wie er durch die Speicherung von Erfahrungen reflektiert. Wir verbessern kontinuierlich das Verhalten des Agenten, indem wir ihn aus jeder Runde lernen lassen. Durch diese Schleife machen wir das System anpassungsfähig und selbstkorrigierend. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

 def run_session(self, user_inputs):
       self.session_count += 1
       print(f"n{'='*60}")
       print(f"SESSION {self.session_count}")
       print(f"{'='*60}n")
       outcomes = ()
       for i, user_input in enumerate(user_inputs, 1):
           print(f"Flip {i}")
           print(f"Person: {user_input}")
           state = self.understand(user_input)
           plan = self.plan(state)
           if not plan:
               print("Agent: I am unsure what to do with that.n")
               proceed
           response = self.act(plan(0))
           print(f"Agent: {response}n")
           success="suggest" in plan(0)(0) or 'replace' in plan(0)(0)
           self.replicate(state, plan(0), response, success)
           outcomes.append({
               'flip': i,
               'enter': user_input,
               'intent': state('intent'),
               'motion': plan(0),
               'response': response
           })
       return outcomes

Wir simulieren reale Interaktionen, bei denen der Agent mehrere Benutzereingaben innerhalb einer einzigen Sitzung verarbeitet. Wir beobachten, wie sich der Zyklus Wahrnehmen → Planen → Handeln → Reflektieren immer wieder entfaltet. Während wir Sitzungen durchführen, sehen wir, wie der Agent nach und nach personalisierter und intelligenter wird. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def evaluate_memory_usage(agent):
   print("n" + "="*60)
   print("MEMORY ANALYSIS")
   print("="*60 + "n")
   print(f"Episodic Reminiscence:")
   print(f"  Complete episodes saved: {len(agent.episodic_memory.episodes)}")
   if agent.episodic_memory.episodes:
       print(f"  Oldest episode: {agent.episodic_memory.episodes(0)('timestamp')}")
       print(f"  Newest episode: {agent.episodic_memory.episodes(-1)('timestamp')}")
   print(f"nSemantic Reminiscence:")
   print(f"  Discovered preferences: {len(agent.semantic_memory.preferences)}")
   for pref, worth in sorted(agent.semantic_memory.preferences.gadgets(), key=lambda x: x(1), reverse=True)(:5):
       print(f"    {pref}: {worth:.3f}")
   print(f"n  Motion patterns discovered: {len(agent.semantic_memory.patterns)}")
   print(f"n  Success charges by context-action:")
   for key, stats in checklist(agent.semantic_memory.success_rates.gadgets())(:5):
       if stats('whole') > 0:
           charge = stats('success') / stats('whole')
           print(f"    {key}: {charge:.2%} ({stats('success')}/{stats('whole')})")


def compare_sessions(results_history):
   print("n" + "="*60)
   print("CROSS-SESSION ANALYSIS")
   print("="*60 + "n")
   for i, ends in enumerate(results_history, 1):
       recommendation_quality = sum(1 for r in outcomes if 'preferences' in r('response').decrease())
       print(f"Session {i}:")
       print(f"  Turns: {len(outcomes)}")
       print(f"  Customized responses: {recommendation_quality}")

Wir analysieren, wie effektiv der Agent seine Erinnerungen nutzt. Wir überprüfen gespeicherte Episoden, erlernte Präferenzen und Erfolgsmuster, um zu bewerten, wie sich der Agent entwickelt. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def run_demo():
   agent = MemoryAgent()
   print("n SCENARIO: Agent learns consumer preferences over a number of periods")
   session1_inputs = (
       "Hello, I am searching for one thing to learn",
       "I actually like sci-fi books",
       "Are you able to suggest one thing?",
   )
   results1 = agent.run_session(session1_inputs)
   session2_inputs = (
       "I am bored, what ought to I learn?",
       "Really, I additionally get pleasure from fantasy novels",
       "Give me a advice",
   )
   results2 = agent.run_session(session2_inputs)
   session3_inputs = (
       "What do you recommend for tonight?",
       "I am within the temper for thriller too",
       "Advocate one thing primarily based on what you recognize about me",
   )
   results3 = agent.run_session(session3_inputs)
   evaluate_memory_usage(agent)
   compare_sessions((results1, results2, results3))
   print("n" + "="*60)
   print("EPISODIC MEMORY RETRIEVAL TEST")
   print("="*60 + "n")
   question = "suggest sci-fi"
   comparable = agent.episodic_memory.retrieve_similar(question, ok=3)
   print(f"Question: '{question}'")
   print(f"Retrieved {len(comparable)} comparable episodes:n")
   for ep in comparable:
       print(f"  State: {ep('state')}")
       print(f"  Motion: {ep('motion')}")
       print(f"  Final result: {ep('consequence')(:50)}...")
       print()


if __name__ == "__main__":
   print("="*60)
   print("MEMORY & LONG-TERM AUTONOMY IN AGENTIC SYSTEMS")
   print("="*60)
   run_demo()
   print("n Tutorial full! Key takeaways:")
   print("  • Episodic reminiscence shops particular experiences")
   print("  • Semantic reminiscence generalizes patterns")
   print("  • Brokers enhance suggestions over periods")
   print("  • Reminiscence retrieval guides future choices")

Wir bringen alles zusammen, indem wir mehrere Sitzungen durchführen und den Speicherabruf testen. Wir beobachten, wie sich der Agent über Interaktionen hinweg verbessert und verfeinern Empfehlungen auf der Grundlage des gesammelten Wissens. Diese umfassende Demo veranschaulicht, wie sich aus den von uns entwickelten Speichersystemen auf natürliche Weise langfristige Autonomie ergibt.

Zusammenfassend erkennen wir, wie die Kombination aus episodischem und semantischem Gedächtnis es uns ermöglicht, Agenten zu entwickeln, die kontinuierlich lernen und im Laufe der Zeit immer bessere Entscheidungen treffen. Wir beobachten, wie der Agent Empfehlungen verfeinert, Pläne anpasst und vergangene Erfahrungen abruft, um seine Reaktionen Sitzung für Sitzung zu verbessern. Durch diese Mechanismen sehen wir, wie aus einfachen, aber effektiven Gedächtnisstrukturen langfristige Autonomie entsteht.

Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. Schauen Sie sich gerne bei uns um GitHub-Seite für Tutorials, Codes und Notebooks. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser Publication. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Asif Razzaq ist CEO von Marktechpost Media Inc.. Als visionärer Unternehmer und Ingenieur setzt sich Asif dafür ein, das Potenzial der künstlichen Intelligenz für das soziale Wohl zu nutzen. Sein jüngstes Unterfangen ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch eine ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die sowohl technisch fundiert als auch für ein breites Publikum leicht verständlich ist. Die Plattform verfügt über mehr als 2 Millionen monatliche Aufrufe, was ihre Beliebtheit beim Publikum verdeutlicht.

Folgen Sie MARKTECHPOST: Fügen Sie uns als bevorzugte Quelle bei Google hinzu.

Okay, das ist zu viel. Die Arbeit mit ChatGPT 4o mit Canvas ist ein Hack.

Uns conflict bewusst, wie weit LLMs und KI-Instruments fortgeschritten sind, aber diese Funktion bringt die Dinge auf eine ganz neue Ebene. Glaubst du, dass du nur ein paar Vorschläge und Änderungen bekommst? Nein, Sie sind dabei, Ihren gesamten Arbeitsablauf zu verändern.

ChatGPT 4o mit Canvas bietet eine effiziente Möglichkeit, mit KI zu interagieren und Ihnen ein interaktiveres Erlebnis zu bieten. Mit der Canvas-Funktion können Sie Dokumente nahtlos erstellen, bearbeiten und verwalten und eignen sich somit perfekt für die Erstellung von Inhalten, Brainstorming und Zusammenarbeit.

In diesem Leitfaden führen wir Sie durch alles, was Sie über die Verwendung von ChatGPT 4o mit Canvas wissen müssen, basierend auf unseren Erfahrungen aus erster Hand mit dem Device.

Was ist ChatGPT 4o mit Canvas?

Canvas ist ein flexibles, in ChatGPT 4o integriertes Device, mit dem Sie Dokumente strukturiert erstellen und bearbeiten können. Sie erhalten Echtzeitbearbeitung, Versionskontrolle und die Generierung umfangreicher Inhalte – alles an derselben Stelle, an der Sie mit ChatGPT interagieren.

Egal, ob Sie lange Artikel schreiben, Entwürfe verwalten oder einfach nur Ihre Gedanken visuell ordnen, Canvas steht Ihnen zur Seite. Die Stärke von Canvas liegt in seiner Fähigkeit, sich an Ihren Arbeitsablauf anzupassen und eine reibungslose, benutzerfreundliche Oberfläche bereitzustellen, die Ihre gesamte Arbeit organisiert und zugänglich hält.

Mit ChatGPT 4o mit Leinwandkönnen Sie zwischen dem Brainstorming von Ideen, dem Entwerfen, Bearbeiten und Verfeinern Ihrer Arbeit wechseln – und erhalten gleichzeitig hilfreiche KI-Vorschläge. Es ist als Ihr ultimativer Begleiter bei der Erstellung von Inhalten konzipiert.

Hauptfunktionen von ChatGPT 4o mit Canvas

Mit Canvas können Sie direkt in ein leeres Dokument springen und interaktiv mit der Arbeit beginnen. Folgendes können Sie tun:

• Erstellen Sie neue Dokumente von Grund auf, was best ist, wenn Sie Inspiration finden.
• Bearbeiten und verfeinern Sie Ihre Inhalte in mehreren Sitzungen und stellen Sie so sicher, dass Sie die Freiheit haben, Ihre Arbeit noch einmal zu überdenken und zu perfektionieren.

Diese Flexibilität macht es sowohl für kurzfristige als auch für langfristige Projekte geeignet. Egal, ob Sie kurze Notizen machen oder an einem umfangreichen Bericht arbeiten müssen, Canvas bietet die Instruments, die Sie benötigen, um alles an einem Ort zu speichern.

Mit ChatGPT 4o mit Canvas können Sie verschiedene Arten von Inhalten hinzufügen, darunter:

• Textual content mit verschiedenen Formatierungsoptionen, mit denen Sie wichtige Punkte hervorheben können.
• Hyperlinks, Pay attention und Tabellen machen Ihre Dokumente informativ und einfach zu navigieren.
• Bilder und andere Medien heben Ihre Inhalte hervor und verwandeln einfachen Textual content in ein ansprechendes visuelles Erlebnis.

Mit diesen Funktionen ist Canvas ein umfassendes Device zur Inhaltserstellung. Sie können optisch ansprechende Dokumente erstellen, die nicht nur informativ, sondern auch ansprechend für Ihr Publikum sind.

ChatGPT 4o mit Canvas verfügt über mehrere Instruments, die Ihnen beim Polieren Ihrer Inhalte helfen:

• Schlagen Sie Änderungen vor: Markieren Sie Teile Ihres Textes und erhalten Sie Verbesserungsvorschläge. Wenn Sie diese Funktion verwenden, werden Ihnen hervorgehobene Bereiche und spezifische Hinweise zur Verbesserung Ihrer Inhalte angezeigt. Dies ist perfekt, wenn Sie nicht weiterkommen oder eine neue Perspektive benötigen.
• Länge anpassen: Passen Sie mit einem Schieberegler die Länge Ihres Textes an – machen Sie ihn ausdrucksvoller oder erweitern Sie ihn, um ihm mehr Tiefe zu verleihen. Wir haben diese Funktion genutzt, um unseren detaillierten Inhaltsplan in einem prägnanten Format zusammenzufassen. Es eignet sich perfekt zur Anpassung an die Bedürfnisse Ihres Publikums und stellt sicher, dass Ihre Botschaft entsprechend zugeschnitten ist.
• Leseniveau: Passen Sie den Ton Ihres Textes an, indem Sie ein Leseniveau auswählen, vom Kindergarten- bis zum Hochschulniveau. Dies macht es einfach, Inhalte für unterschiedliche Zielgruppen anzupassen, egal ob Sie etwas Einfaches oder etwas Anspruchsvolleres benötigen. Wir fanden dies besonders nützlich, wenn wir Inhalte für unterschiedliche Kundengruppen erstellen.
• Fügen Sie den letzten Schliff hinzu: Geben Sie Ihren Inhalten eine abschließende Überprüfung, um sicherzustellen, dass alles reibungslos und verfeinert ist. Das Klicken auf diese Choice führte zu einem strukturierten und intestine organisierten Artikel mit korrekten Überschriften und einem ausgefeilten Ablauf. Es ist der letzte Schliff, der Ihren Inhalten Glanz verleiht und einen Rohentwurf in etwas für die Veröffentlichung verwandelt.
• Emojis hinzufügen: Fügen Sie einige relevante Emojis hinzu, um Ihre Inhalte ansprechender und ausdrucksvoller zu gestalten. Wir haben diese Funktion getestet und relevante Emojis hinzugefügt, um wichtige Punkte hervorzuheben und den Inhalt lebendiger zu machen. Emojis können eine persönliche Observe verleihen und dabei helfen, Emotionen zu vermitteln oder wichtige Abschnitte Ihres Textes hervorzuheben, was besonders bei sozialen Medien oder informellen Inhalten effektiv sein kann.

Sie können auf diese Werkzeuge zugreifen, indem Sie auf das Stiftsymbol in der unteren rechten Ecke Ihrer Leinwand klicken. Das Bearbeitungsmenü bietet Ihnen alle diese Optionen, um sicherzustellen, dass Ihre Inhalte glänzen, und bietet Ihnen die Flexibilität, Ihre Arbeit genau so zu gestalten, wie Sie es möchten.

So verwenden Sie ChatGPT 4o mit Canvas: Unsere Erfahrung

Schritt 1: Erstellen eines neuen Dokuments

Öffnen Sie ChatGPT wie gewohnt. Wählen Sie das Modell „ChatGPT 4o mit Canvas“.

Schritt 2: Inhalte hinzufügen

Als wir Canvas zum ersten Mal ausprobierten, wollten wir einen flexiblen Tagesplan erstellen, um Inhalte für mehrere Blogs und Web sites zu verwalten.

Die von uns verwendete Eingabeaufforderung conflict:

„Ich möchte mir einen flexiblen Tagesplan erstellen. Ich habe 4 verschiedene Web sites/Blogs. Ich schreibe von Montag bis Freitag Inhalte für sie. Nennen wir sie: Kanal A: 4 lange Artikel professional Tag, Kanal B: 2 Social-Media-Beiträge, Kanal C: 1 langer Unternehmensblog-Artikel, Kanal D: 1 Originalartikel in meiner Muttersprache. Ich beginne um 10:00 Uhr mit der Arbeit und beende um 18:00 Uhr: 00.“

ChatGPT kam mit einem detaillierten Zeitplan zurück, der uns dabei half, unsere Arbeitsbelastung auszugleichen und gleichzeitig Zeit für Pausen zu haben. Sie können das Gleiche tun – beginnen Sie einfach mit der Eingabe im Canvas und bitten Sie ChatGPT um Hilfe bei Ideen, der Verbesserung Ihres Schreibens oder der Strukturierung Ihrer Pläne.

Anschließend haben wir das Canvas-Panel verwendet, um diesen Zeitplan zu verfeinern. Auf der rechten Seite haben wir direkt Änderungen vorgenommenwährend auf der linken Seite, wir könnten ChatGPT veranlassen, komplexere Anpassungen vorzunehmen.

Dieser duale Ansatz ermöglichte es uns, unseren Arbeitsablauf anzupassen, wodurch es einfacher wurde, Ideen zu verfeinern und schnelle Anpassungen in Echtzeit vorzunehmen.

Als nächstes baten wir um eine Zusammenfassung unseres Zeitplans in tabellarischer Kind. Das Ergebnis? Eine übersichtliche, übersichtliche Tabelle, die den Zeitplan viel leichter verständlich machte. Canvas macht es wirklich einfach, von einem absatzlastigen Plan zu einem optisch klaren und organisierten Format zu wechseln.

Diese Artwork der Transformation ist besonders hilfreich, wenn Informationen Kunden oder Teammitgliedern präsentiert werden, die einen Überblick auf einen Blick bevorzugen.

Schritt 3: Bearbeitungswerkzeuge verwenden

Nachdem wir den Zeitplan erstellt hatten, untersuchten wir die Bearbeitungswerkzeuge:

• Schlagen Sie Änderungen vor: Dieses Device hebt bestimmte Teile unseres Inhalts gelb hervor und bietet umsetzbare Verbesserungshinweise. Wir fanden dies sehr hilfreich, um Klarheit und Fluss zu verbessern. Es ist, als ob Sie einen Redakteur an Ihrer Seite hätten, der Ihnen genau zeigt, was optimiert werden muss.

• Emojis hinzufügen: Das Hinzufügen von Emojis conflict ein Kinderspiel. Wir haben auf die Choice geklickt und relevante Emojis wurden automatisch hinzugefügt, um den Inhalt ansprechender zu gestalten. Diese kleine Ergänzung machte einen großen Unterschied darin, wie zugänglich sich der Inhalt anfühlte.
• Fügen Sie den letzten Schliff hinzu: Wir haben auf diese Choice geklickt, um den gesamten Artikel zu verbessern. Es verwandelte unseren Entwurf in einen strukturierteren Artikel mit richtigen Überschriften und einem professionellen Contact, sodass er zur Veröffentlichung bereit conflict. Die Politur-Funktion hat unseren Entwurf wirklich von „intestine“ zu „großartig“ gemacht und sich um alle kleinen Particulars gekümmert, die sonst zeitaufwändig sein könnten.

ChatGPT conflict Assistent, jetzt ist er Co-Autor

Als wir anfingen, ChatGPT 4o mit Canvas zu verwenden, stellten wir fest, wie viel einfacher es unseren Arbeitsablauf beim Erstellen, Bearbeiten und Zusammenarbeiten an Dokumenten machte. Ganz gleich, ob wir einen Artikel verfassten, einen Bericht verfassten oder einfach nur Ideen sammelten: Canvas bot eine intuitive Plattform, die KI-Unterstützung nahtlos mit Dokumentenverwaltungsfunktionen kombinierte. Es fühlte sich an, als ob immer ein hilfsbereiter Co-Autor da wäre, der uns durch jede Section des Schreibprozesses begleitete, von Anfang bis Ende.

Bildnachweis: OpenAI