automata
v0.0.4
automata s'inspire de la théorie selon laquelle le code est essentiellement une forme de mémoire et, lorsqu'elle est dotée des bons outils, l'IA peut développer des capacités en temps réel qui peuvent potentiellement conduire à la création d'AGI. Le mot automata vient du mot grec αὐτόματος, signifiant « agissant automatiquement, volontairement, se déplaçant automatiquement » et la théorie automata est l'étude des machines et automata abstraits, ainsi que des problèmes informatiques qui peuvent être résolus en les utilisant. .
Plus d’informations suivent ci-dessous.
Suivez ces étapes pour configurer l'environnement automata
# Clone the repository
git clone [email protected]:emrgnt-cmplxty/ automata .git && cd automata /
# Initialize git submodules
git submodule update --init
# Install poetry and the project
pip3 install poetry && poetry install
# Configure the environment and setup files
poetry run automata configureExtrayez l'image Docker :
$ docker pull ghcr.io/emrgnt-cmplxty/ automata :latestExécutez l'image Docker :
$ docker run --name automata _container -it --rm -e OPENAI_API_KEY= < your_openai_key > -e GITHUB_API_KEY= < your_github_key > ghcr.io/emrgnt-cmplxty/ automata :latestCela démarrera un conteneur Docker avec automata installés et ouvrira un shell interactif que vous pourrez utiliser.
Les utilisateurs Windows devront peut-être installer la prise en charge C++ via le « Développement de bureau avec C++ » de Visual Studio pour certaines dépendances.
De plus, une mise à jour vers gcc-11 et g++-11 peut être nécessaire. Cela peut être fait en exécutant les commandes suivantes :
# Adds the test toolchain repository, which contains newer versions of software
sudo add-apt-repository ppa:ubuntu-toolchain-r/test
# Updates the list of packages on your system
sudo apt update
# Installs gcc-11 and g++-11 packages
sudo apt install gcc-11 g++-11
# Sets gcc-11 and g++-11 as the default gcc and g++ versions for your system
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 60 --slave /usr/bin/g++ g++ /usr/bin/g++-11Les index SCIP sont requis pour exécuter la recherche automata . Ces indices sont utilisés pour créer le graphe de code qui relie les symboles par dépendances dans la base de code. De nouveaux index sont générés et téléchargés périodiquement pour la base de code automata , mais les programmeurs doivent les générer manuellement si nécessaire pour leur développement local. Si vous rencontrez des problèmes, nous vous recommandons de vous référer aux instructions ici.
# Install dependencies and run indexing on the local codebase
poetry run automata install-indexing # Refresh the code embeddings (after making local changes)
poetry run automata run-code-embedding
# Refresh the documentation + embeddings
poetry run automata run-doc-embedding --embedding-level=2
Les commandes suivantes illustrent comment exécuter le système avec une instruction triviale. Il est recommandé que votre exécution initiale soit de ce type pour garantir que le système fonctionne comme prévu.
# Run a single agent w/ trivial instruction
poetry run automata run-agent --instructions= " Return true " --model=gpt-3.5-turbo-0613
# Run a single agent w/ a non-trivial instruction
poetry run automata run-agent --instructions= " Explain what automata Agent is and how it works, include an example to initialize an instance of automata Agent. " automata fonctionne en combinant des modèles de langage étendus, tels que GPT-4, avec une base de données vectorielle pour former un système intégré capable de documenter, de rechercher et d'écrire du code. La procédure démarre par la génération d’une documentation complète et d’instances de code. Ceci, associé aux capacités de recherche, constitue la base du potentiel d'auto-codage des automata .
automata utilise des outils en aval pour exécuter des tâches de codage avancées, renforçant ainsi continuellement son expertise et son autonomie. Cette approche d'auto-codage reflète le travail d'un artisan autonome, où les outils et les techniques sont constamment affinés en fonction des commentaires et de l'expérience accumulée.
Parfois, la meilleure façon de comprendre un système compliqué est de commencer par comprendre un exemple simple. L'exemple suivant illustre comment exécuter votre propre agent automata . L'agent sera initialisé avec une instruction triviale, puis tentera d'écrire du code pour exécuter l'instruction. L'agent renverra alors le résultat de sa tentative.
from automata . config . base import AgentConfigName , OpenAI automata AgentConfigBuilder
from automata . agent import OpenAI automata Agent
from automata . singletons . dependency_factory import dependency_factory
from automata . singletons . py_module_loader import py_module_loader
from automata . tools . factory import AgentToolFactory
# Initialize the module loader to the local directory
py_module_loader . initialize ()
# Construct the set of all dependencies that will be used to build the tools
toolkit_list = [ "context-oracle" ]
tool_dependencies = dependency_factory . build_dependencies_for_tools ( toolkit_list )
# Build the tools
tools = AgentToolFactory . build_tools ( toolkit_list , ** tool_dependencies )
# Build the agent config
agent_config = (
OpenAI automata AgentConfigBuilder . from_name ( " automata -main" )
. with_tools ( tools )
. with_model ( "gpt-4" )
. build ()
)
# Initialize and run the agent
instructions = "Explain how embeddings are used by the codebase"
agent = OpenAI automata Agent ( instructions , config = agent_config )
result = agent . run () Les intégrations dans cette base de code sont représentées par des classes telles que SymbolCodeEmbedding et SymbolDocEmbedding . Ces classes stockent des informations sur un symbole et ses intégrations respectives qui sont des vecteurs représentant le symbole dans un espace de grande dimension.
Des exemples de ces classes sont : SymbolCodeEmbedding une classe utilisée pour stocker les intégrations liées au code d'un symbole. SymbolDocEmbedding une classe utilisée pour stocker les intégrations liées à la documentation d'un symbole.
Exemple de code pour créer une instance de « SymbolCodeEmbedding » :
import numpy as np
from automata . symbol_embedding . base import SymbolCodeEmbedding
from automata . symbol . parser import parse_symbol
symbol_str = 'scip-python python automata 75482692a6fe30c72db516201a6f47d9fb4af065 ` automata .agent.agent_enums`/ActionIndicator#'
symbol = parse_symbol ( symbol_str )
source_code = 'symbol_source'
vector = np . array ([ 1 , 0 , 0 , 0 ])
embedding = SymbolCodeEmbedding ( symbol = symbol , source_code = source_code , vector = vector )Exemple de code pour créer une instance de « SymbolDocEmbedding » :
from automata . symbol_embedding . base import SymbolDocEmbedding
from automata . symbol . parser import parse_symbol
import numpy as np
symbol = parse_symbol ( 'your_symbol_here' )
document = 'A document string containing information about the symbol.'
vector = np . random . rand ( 10 )
symbol_doc_embedding = SymbolDocEmbedding ( symbol , document , vector )Si vous souhaitez contribuer à automata , assurez-vous de consulter les directives de contribution. Ce projet adhère au code de conduite d' automata . En participant, vous êtes censé respecter ce code.
Nous utilisons les problèmes GitHub pour le suivi des demandes et des bogues. Veuillez consulter les discussions automata pour les questions et discussions générales, et veuillez adresser des questions spécifiques.
Le projet automata s'efforce de respecter les meilleures pratiques généralement acceptées en matière de développement de logiciels open source.
Le but ultime du projet automata est d’atteindre un niveau de compétence lui permettant de concevoir, d’écrire, de tester et d’affiner de manière indépendante des systèmes logiciels complexes. Cela inclut la capacité de comprendre et de naviguer dans de grandes bases de code, de raisonner sur l'architecture logicielle, d'optimiser les performances et même d'inventer de nouveaux algorithmes ou structures de données si nécessaire.
Bien que la réalisation complète de cet objectif soit probablement une entreprise complexe et à long terme, chaque étape progressive vers cet objectif a non seulement le potentiel d'augmenter considérablement la productivité des programmeurs humains, mais également de mettre en lumière des questions fondamentales en matière d'IA et d'informatique. science.
automata est sous licence Apache License 2.0.
Ce projet est une extension d'un effort initial entre emrgnt-cmplxty et maks-ivanov qui a commencé avec ce référentiel.
