automata
v0.0.4
automata se inspiran en la teoría de que el código es esencialmente una forma de memoria y, cuando se le proporciona las herramientas adecuadas, la IA puede desarrollar capacidades en tiempo real que potencialmente pueden conducir a la creación de AGI. La palabra automata proviene de la palabra griega αὐτόματος, que denota "que actúa por sí mismo, tiene voluntad propia y se mueve por sí mismo", y la teoría automata es el estudio de las máquinas abstractas y automata , así como los problemas computacionales que pueden resolverse usándolos. .
Más información sigue a continuación.
Siga estos pasos para configurar el entorno 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 configureExtraiga la imagen de Docker:
$ docker pull ghcr.io/emrgnt-cmplxty/ automata :latestEjecute la imagen de 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 :latestEsto iniciará un contenedor Docker con automata instalados y abrirá un shell interactivo para su uso.
Es posible que los usuarios de Windows necesiten instalar compatibilidad con C++ a través del "Desarrollo de escritorio con C++" de Visual Studio para determinadas dependencias.
Además, es posible que sea necesario actualizar a gcc-11 y g++-11. Esto se puede hacer ejecutando los siguientes comandos:
# 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++-11Se requieren índices SCIP para ejecutar la búsqueda automata . Estos índices se utilizan para crear el gráfico de código que relaciona los símbolos por dependencias en todo el código base. Periódicamente se generan y cargan nuevos índices para el código base automata , pero los programadores deben generarlos manualmente si es necesario para su desarrollo local. Si tiene problemas, le recomendamos consultar las instrucciones aquí.
# 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
Los siguientes comandos ilustran cómo ejecutar el sistema con una instrucción trivial. Se recomienda que su ejecución inicial sea algo de este tipo para garantizar que el sistema funcione como se esperaba.
# 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 funcionan combinando modelos de lenguaje grandes, como GPT-4, con una base de datos vectorial para formar un sistema integrado capaz de documentar, buscar y escribir código. El procedimiento comienza con la generación de documentación completa e instancias de código. Esto, junto con las capacidades de búsqueda, forma la base del potencial de autocodificación de automata .
automata emplea herramientas posteriores para ejecutar tareas de codificación avanzadas, desarrollando continuamente su experiencia y autonomía. Este enfoque de autocodificación refleja el trabajo de un artesano autónomo, donde las herramientas y técnicas se refinan constantemente en función de la retroalimentación y la experiencia acumulada.
A veces la mejor manera de entender un sistema complicado es empezar por entender un ejemplo básico. El siguiente ejemplo ilustra cómo ejecutar su propio agente automata . El agente se inicializará con una instrucción trivial y luego intentará escribir código para cumplir la instrucción. Luego, el agente devolverá el resultado de su intento.
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 () Las incrustaciones en este código base están representadas por clases como SymbolCodeEmbedding y SymbolDocEmbedding . Estas clases almacenan información sobre un símbolo y sus respectivas incrustaciones, que son vectores que representan el símbolo en un espacio de alta dimensión.
Ejemplos de estas clases son: SymbolCodeEmbedding una clase utilizada para almacenar incrustaciones relacionadas con el código de un símbolo. SymbolDocEmbedding una clase utilizada para almacenar incrustaciones relacionadas con la documentación de un símbolo.
Ejemplo de código para crear una instancia 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 )Ejemplo de código para crear una instancia 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 desea contribuir a automata , asegúrese de revisar las pautas de contribución. Este proyecto se adhiere al código de conducta de automata . Al participar, se espera que respete este código.
Usamos problemas de GitHub para rastrear solicitudes y errores; consulte las Discusiones automata para preguntas y debates generales, y dirija preguntas específicas.
El proyecto automata se esfuerza por cumplir con las mejores prácticas generalmente aceptadas en el desarrollo de software de código abierto.
El objetivo final del proyecto de automata es alcanzar un nivel de competencia en el que pueda diseñar, escribir, probar y perfeccionar de forma independiente sistemas de software complejos. Esto incluye la capacidad de comprender y navegar por grandes bases de código, razonar sobre la arquitectura del software, optimizar el rendimiento e incluso inventar nuevos algoritmos o estructuras de datos cuando sea necesario.
Si bien es probable que la realización completa de este objetivo sea una tarea compleja y de largo plazo, cada paso gradual hacia él no sólo tiene el potencial de aumentar dramáticamente la productividad de los programadores humanos, sino también de arrojar luz sobre cuestiones fundamentales en IA y computación. ciencia.
automata tiene la licencia Apache 2.0.
Este proyecto es una extensión de un esfuerzo inicial entre emrgnt-cmplxty y maks-ivanov que comenzó con este repositorio.
