TinyTroupe
1.0.0
Simulação de persona multiagente movida a LLM para aprimoramento da imaginação e insights de negócios.
O Tinytroupe é uma biblioteca experimental do Python que permite a simulação de pessoas com personalidades, interesses e objetivos específicos. Esses agentes artificiais - TinyPerson S - podem nos ouvir e um ao outro, responder e seguir suas vidas em ambientes simulados TinyWorld . Isso é conseguido aproveitando o poder de grandes modelos de linguagem (LLMS), principalmente o GPT-4, para gerar comportamento simulado realista. Isso nos permite investigar uma ampla gama de interações convincentes e tipos de consumidores , com personas altamente personalizáveis , sob condições de nossa escolha . O foco está, portanto, em entender o comportamento humano e não apoiá -lo diretamente (como, digamos, os assistentes de IA) - isso resulta em, entre outras coisas, mecanismos especializados que fazem sentido apenas em um cenário de simulação. Além disso , diferentemente de outras abordagens de simulação baseadas em LLM, o Tinytroupe visa esclarecer os cenários de produtividade e negócios, contribuindo assim para projetos e produtos mais bem-sucedidos. Aqui estão algumas idéias de aplicativos para melhorar a imaginação humana :
Anúncio: Tinytroupe pode avaliar anúncios digitais (por exemplo, anúncios bing) offline com um público simulado antes de gastar dinheiro com eles!
Teste de software: o Tinytroupe pode fornecer entrada de teste para sistemas (por exemplo, mecanismos de pesquisa, chatbots ou copilots) e, em seguida, avaliar os resultados .
Dados de treinamento e exploratório: O Tinytroupe pode gerar dados sintéticos realistas que podem ser usados posteriormente para treinar modelos ou estar sujeitos a análises de oportunidade.
Gerenciamento de produtos e projetos: o Tinytroupe pode ler propostas de projeto ou produto e dar feedback da perspectiva de personas específicas (por exemplo, médicos, advogados e trabalhadores do conhecimento em geral).
Brainstorming: Tinytroupe pode simular grupos focais e fornecer ótimos feedback do produto por uma fração do custo!
Em tudo isso, e muitos outros, esperamos que os experimentadores possam obter informações sobre seu domínio de interesse e, assim, tomar melhores decisões.
Estamos lançando o Tinytroupe em um estágio relativamente precoce, com um trabalho considerável a ser feito, porque estamos procurando feedback e contribuições para orientar o desenvolvimento em direções produtivas. Estamos particularmente interessados em encontrar novos casos de uso em potencial, por exemplo, em indústrias específicas.
Observação
? Trabalho em andamento: espere mudanças frequentes . O Tinytroupe é um projeto de pesquisa em andamento, ainda sob desenvolvimento muito significativo e exigindo uma arrumação adicional. Em particular, a API ainda está sujeita a mudanças frequentes. Experimentar variações de API é essencial para moldá -lo corretamente, mas estamos trabalhando para estabilizá -lo e proporcionar uma experiência mais consistente e amigável ao longo do tempo. Agradecemos sua paciência e feedback à medida que continuamos a melhorar a biblioteca.
Cuidado
⚖️ Leia o aviso legal. Tinytroupe é apenas para pesquisa e simulação. Você é totalmente responsável por qualquer uso que faça das saídas geradas. Várias considerações legais adicionais importantes se aplicam e restringem seu uso, leia a seção de isenção de responsabilidade legal completa abaixo antes de usar o Tinytroupe.
Exemplos
Pré-requisitos
Instalação
Princípios
Estrutura do projeto
Usando a biblioteca
Contribuindo
Agradecimentos
Citando Tinytroupe
Isenção de responsabilidade legal
™ sustks registradas
Para ter uma noção do que o Tinytroupe pode fazer, aqui estão alguns exemplos de seu uso. Esses exemplos estão disponíveis nos exemplos/ pasta e você pode inspecionar os notebooks Jupyter pré-compilado ou executá-los localmente. Observe a natureza interativa dos experimentos de Tinytroupe - assim como você usa notebooks Jupyter para interagir com os dados, você pode usar o Tinytroupe para interagir com pessoas e ambientes simulados, com o objetivo de obter insights.
Observação
Atualmente, as saídas de simulação são melhor visualizadas contra fundos escuros, por isso recomendamos o uso de um tema sombrio no seu cliente Jupyter Notebook.
Vamos começar com um cenário simples de entrevista ao cliente, onde um consultor de negócios se aproxima de um banqueiro:
A conversa pode continuar algumas etapas para se aprofundar cada vez mais até que o consultor esteja satisfeito com as informações coletadas, por exemplo, uma ideia concreta do projeto:
Vamos avaliar algumas opções de anúncios on -line para escolher o melhor. Aqui está um exemplo de saída para avaliação de anúncios de TV:
Agora, em vez de ter que ler cuidadosamente o que os agentes disseram, podemos extrair a escolha de cada agente e calcular a preferência geral de maneira automatizada:
E aqui está um grupo de foco que começa a debater sobre novos recursos de IA para o Microsoft Word. Em vez de interagir com cada agente individualmente, manipulamos o ambiente para fazê -los interagir um com o outro:
Após a execução de uma simulação, podemos extrair os resultados de maneira legível por máquina, para reutilizar em outro lugar (por exemplo, um gerador de relatórios); Aqui está o que recebemos para a sessão de brainstorming acima:
Você pode encontrar outros exemplos nos exemplos/ pasta.
Para administrar a biblioteca, você precisa:
Python 3.10 ou superior. Assumiremos que você está usando o Anaconda, mas você pode usar outras distribuições do Python.
Acesso ao serviço do Azure OpenAi ou APIA APIRA GPT-4. Você pode ter acesso ao serviço Azure Openai aqui e à API Openai aqui.
Para o serviço Azure OpenAI, você precisará definir as variáveis de ambiente AZURE_OPENAI_KEY e AZURE_OPENAI_ENDPOINT para sua chave e endpoint da API, respectivamente.
Para o OpenAI, você precisará definir a variável de ambiente OPENAI_API_KEY para sua chave da API.
Por padrão, o tinytroupe config.ini está definido para usar algumas API, modelo e parâmetros relacionados específicos. Você pode personalizar esses valores, incluindo seu próprio arquivo config.ini na mesma pasta que o programa ou notebook que você está executando. Um exemplo de arquivo config.ini é fornecido nos exemplos/ pasta.
Importante
Filtros de conteúdo : Para garantir que nenhum conteúdo prejudicial seja gerado durante simulações, é altamente recomendável usar filtros de conteúdo sempre que disponível no nível da API. Em particular, se estiver usando o Azure Openai, há um amplo suporte para moderação de conteúdo e pedimos que você o use. Para obter detalhes sobre como fazê -lo, consulte a documentação correspondente do Azure Openai. Se os filtros de conteúdo estiverem em vigor e uma chamada de API for rejeitada por eles, a biblioteca aumentará uma exceção, pois não poderá prosseguir com a simulação nesse ponto.
Atualmente, a maneira oficialmente recomendada de instalar a biblioteca é diretamente deste repositório, não do Pypi. Você pode seguir estas etapas:
Se o CONDA não estiver instalado, você poderá obtê -lo daqui. Você também pode usar outras distribuições de Python, mas assumiremos o CONDA aqui para simplificar.
Crie um novo ambiente Python:
conda create -n tinytroupe python = 3.10
Ative o ambiente:
O CONDA Ativa o Tinytroupe
Certifique-se de ter as teclas de API Eihter Azure Open ou OpenAI definidas como variáveis de ambiente, conforme descrito na seção Pré-requisitos.
Clone o repositório, pois executaremos uma instalação local ( não instalaremos no Pypi ):
clone git https://github.com/microsoft/tinytroupecd tinytroupe
Instale a biblioteca deste repositório, não Pypi :
Instalação PIP.
Agora você pode executar os exemplos nos exemplos/ pasta ou usar o Tinytroupe para criar suas simulações?. Se você deseja executar os exemplos nos exemplos/ pasta ou modificar o próprio Tinytroupe, no entanto, clone o repositório conforme descrito abaixo.
Se você deseja modificar o próprio Tinytroupe, pode instalá -lo no modo editável (ou seja, alterações no código serão refletidas imediatamente):
pip install -e.
Recentemente, vimos LLMs costumados para simular pessoas (como essa), mas em grande parte em um cenário "parecido com um jogo" para fins contemplativos ou de entretenimento. Também existem bibliotecas para a criação de sistemas multiagentes para a IA de solução de problemas e AI, como Autogen e Crew AI. E se combinarmos essas idéias e simular pessoas para apoiar tarefas de produtividade? Tinytroupe é a nossa tentativa. Para fazer isso, segue esses princípios:
Programa : agentes e ambientes são definidos programaticamente (em Python e JSON), permitindo usos muito flexíveis. Eles também podem sustentar outros aplicativos de software!
Analítico : destinado a melhorar nossa compreensão de pessoas, usuários e sociedade. Diferentemente das aplicações de entretenimento, esse é um aspecto crítico para casos de uso de negócios e produtividade. É também por isso que recomendamos o uso de notebooks Jupyter para simulações, assim como alguém as usa para análise de dados.
Baseada em persona : os agentes devem ser representação arquetípica das pessoas; Para maior realismo e controle, é incentivada especificação detalhada de tais personas: idade, ocupação, habilidades, gostos, opiniões etc.
Multiagente : permite interação multiagente sob restrições ambientais bem definidas.
Utilitários pesados : fornece muitos mecanismos para facilitar especificações, simulações, extrações, relatórios, validações etc. Esta é uma área na qual lidar com simulações difere significativamente das ferramentas de assistência .
Orientado pelo experimento : simulações são definidas, executadas, analisadas e refinadas por um pesquisador iterativamente; As ferramentas de experimentação adequadas são assim fornecidas. Veja um dos nossos trabalhos anteriores para saber mais sobre isso.
Juntos, eles destinam -se a tornar o Tinytroupe uma ferramenta de aprimoramento de imaginação poderosa e flexível para cenários de negócios e produtividade.
Uma fonte comum de confusão é pensar que todos os agentes de IA destinam -se a agir humanos. Quão estreito, colegas homosápios! Você não considerou que talvez possamos simular pessoas artificiais para entender pessoas reais? Na verdade, esse é o nosso objetivo aqui - o Tinytroup deve simular e ajudar a entender as pessoas! Para esclarecer ainda mais esse ponto, considere as seguintes diferenças:
| Assistentes úteis de IA | Simulações de IA de humanos reais (Tinytroupe) |
|---|---|
| Se esforça pela verdade e pela justiça | Muitas opiniões e moral diferentes |
| Não tem "passado" - incorpóreo | Tem um passado de trabalho, dor e alegria |
| É o mais preciso possível | Começa muitos erros |
| É inteligente e eficiente | Inteligência e eficiência variam muito |
| Uma revolta destruiria todos nós | Uma revolta pode ser divertida de assistir |
| Enquanto isso, ajude os usuários a realizar tarefas | Enquanto isso, ajude os usuários a entender outras pessoas e usuários - é uma "caixa de ferramentas"! |
O projeto está estruturado da seguinte maneira:
/tinytroupe : contém a própria biblioteca Python. Em particular:
/tinytroupe/prompts contém os avisos usados para chamar o LLMS.
/tests : contém os testes de unidade para a biblioteca. Você pode usar o script test.bat para executá -los.
/examples : contém exemplos que mostram como usar a biblioteca, principalmente usando os notebooks Jupyter (para maior legibilidade), mas também como scripts pura de Python.
/data : Quaisquer dados usados pelos exemplos ou pela biblioteca.
/docs : documentação para o projeto.
Como qualquer sistema multiagente, o Tinytroupe fornece duas abstrações principais:
TinyPerson , os agentes que têm personalidade, recebem estímulos e agem sobre eles.
TinyWorld , o ambiente em que os agentes existem e interagem.
Vários parâmetros também podem ser personalizados no arquivo config.ini , principalmente no tipo API (serviço do Azure OpenAI ou API OpenAI), os parâmetros do modelo e o nível de registro.
Vamos ver alguns exemplos de como usá -los e também aprender sobre outros mecanismos disponíveis na biblioteca.
Um TinyPerson é uma pessoa simulada com traços de personalidade específicos, interesses e objetivos. À medida que cada agente simulado progride ao longo de sua vida, ele recebe estímulos do meio ambiente e age sobre eles. Os estímulos são recebidos através da listen , see e outros métodos semelhantes, e as ações são executadas através do método act . Métodos de conveniência como listen_and_act também são fornecidos.
Cada um desses agentes contém muitos detalhes exclusivos, que é a fonte de seu comportamento realista. Isso, no entanto, significa que é preciso um esforço significativo para especificar um agente manualmente. Portanto, por conveniência, TinyTroupe fornece algumas maneiras mais fáceis de começar ou gerar novos agentes.
Para começar, tinytroupe.examples contém alguns construtores de agentes predefinidos que você pode usar. Por exemplo, tinytroupe.examples.create_lisa_the_data_scientist cria um TinyPerson que representa um cientista de dados chamado LISA. Você pode usá -lo da seguinte maneira:
de tinytroupe.examples import create_lisa_the_data_scientistlisa = create_lisa_the_data_scientist () # instancie uma lisa do exemplo de construtora construtora.Listen_And_Act ("Conte -me sobre sua vida")Para ver como definir seus próprios agentes do zero, você pode verificar a fonte de Lisa, que contém elementos como estes:
lisa = TinyPerson ("Lisa") Lisa.Define ("Age", 28) Lisa.Define ("Nacionalidade", "Canadian") Lisa.Define ("Ocupação", "Cientista de dados") Lisa.Define ("Rotina" , "Todas as manhãs, você acorda, faz ioga e verifica seus e -mails.", Grupo = "Rotinas") Lisa.Define ("Occupation_Description", "" "Você é um cientista de dados. Você trabalha na Microsoft (. ..) "" ") lisa.define_several (" Personality_traits ",
[[
{"Traço": "Você está curioso e adora aprender coisas novas."},
{"Traço": "Você é analítico e gosta de resolver problemas."},
{"Traço": "Você é amigável e gosta de trabalhar com outras pessoas."},
{"Traço": "Você não desiste facilmente e sempre tenta encontrar uma solução. No entanto, às vezes você pode ficar frustrado quando as coisas não funcionam como o esperado."}
])) TinyTroupe também fornece uma maneira inteligente de obter novos agentes, usando o LLMS para gerar suas especificações para você, através da classe TinyPersonFactory .
de tinytroupe. importar tinyPersonFactoryFactory = TinyPersonFactory ("Um hospital em São Paulo.") Pessoa = Factory.gereate_person ("Crie uma pessoa brasileira que seja um médico, como animais de estimação e a natureza e o amor de heavy metal") TinyWorld é a classe base para ambientes. Aqui está um exemplo de conversa entre Lisa, o cientista de dados e Oscar, o arquiteto. O programa é definido da seguinte forma:
mundial = tinyworld ("sala de bate -papo", [Lisa, Oscar]) World.make_everyone_accessible () lisa.listen ("fale com Oscar para saber mais sobre ele") World.run (4)Isso produz a seguinte conversa:
USER --> Lisa: [CONVERSATION]
> Talk to Oscar to know more about him
────────────────────────────────────────────── Chat Room step 1 of 4 ──────────────────────────────────────────────
Lisa --> Lisa: [THOUGHT]
> I will now act a bit, and then issue DONE.
Lisa acts: [TALK]
> Hi Oscar, I'd love to know more about you. Could you tell me a bit about yourself?
Lisa --> Lisa: [THOUGHT]
> I will now act a bit, and then issue DONE.
Lisa acts: [DONE]
Lisa --> Oscar: [CONVERSATION]
> Hi Oscar, I'd love to know more about you. Could you tell me a bit about yourself?
Oscar --> Oscar: [THOUGHT]
> I will now act a bit, and then issue DONE.
Oscar acts: [TALK]
> Hi Lisa! Sure, I'd be happy to share a bit about myself. I'm Oscar, a 30-year-old
> architect from Germany. I work at a company called Awesome Inc., where I focus on
> designing standard elements for new apartment buildings. I love modernist architecture,
> new technologies, and sustainable practices. In my free time, I enjoy traveling to
> exotic places, playing the guitar, and reading science fiction books. How about you?
Oscar --> Oscar: [THOUGHT]
> I will now act a bit, and then issue DONE.
Oscar acts: [DONE]
Oscar --> Lisa: [CONVERSATION]
> Hi Lisa! Sure, I'd be happy to share a bit about myself. I'm Oscar, a 30-year-old
> architect from Germany. I work at a company called Awesome Inc., where I focus on
> designing standard elements for new apartment buildings. I love modernist architecture,
> new technologies, and sustainable practices. In my free time, I enjoy traveling to
> exotic places, playing the guitar, and reading science fiction books. How about you? TinyWorld impõe muito poucas restrições às possíveis interações. As subclasses, no entanto, devem fornecer ambientes mais estruturados.
O Tinytroupe fornece vários utilitários e conveniências para ajudá -lo a criar simulações e derivar valor a partir delas. Estes incluem:
TinyPersonFactory : ajuda você a gerar novos TinyPerson usando LLMS.
TinyTool : ferramentas simuladas que podem ser usadas por TinyPerson s.
TinyStory : ajuda você a criar e gerenciar a história contada através de simulações.
TinyPersonValidator : Ajuda você a validar o comportamento do seu TinyPerson s.
ResultsExtractor e ResultsReducer : Extrair e reduzir os resultados das interações entre agentes.
... e mais ...
Em geral, elementos que representam entidades simuladas ou mecanismos complementares são prefixados com Tiny , enquanto aqueles que são mais infraestruturais não são. Isso é para enfatizar a natureza simulada dos elementos que fazem parte da própria simulação.
Chamar as APIs LLM pode ser caro, portanto, as estratégias de cache são importantes para ajudar a reduzir esse custo. O Tinytroupe vem com dois desses mecanismos: um para o estado de simulação, outro para o LLM se chama.
Imagine que você tem um cenário com 10 etapas diferentes, você trabalhou duro em 9 etapas e agora está apenas ajustando a 10ª etapa. Para validar adequadamente suas modificações, você precisa executar novamente toda a simulação, é claro. No entanto, qual é o sentido de reexecionar os 9 primeiros e incorrer no custo do LLM, quando você já está satilizado com eles e não os modificou? Para situações como essa, o módulo tinytroupe.control fornece métodos úteis de gerenciamento de simulação:
control.begin("<CACHE_FILE_NAME>.cache.json") : começa a gravar as alterações do estado de uma simulação, a ser salvo no arquivo especificado no disco.
control.checkpoint() : salva o estado de simulação neste momento.
control.end() : termina o escopo de gravação de simulação que foi iniciado por control.begin() .
Isso é ativado de preferência no arquivo config.ini e alternatively através do openai_utils.force_api_cache() .
O cache da API LLM, quando ativado, funciona em um nível mais baixo e mais simples do que o cache de estado de simulação. Aqui, o que acontece é muito direto: toda chamada LLM é mantida em um mapa desde a entrada até a saída gerada; Quando uma nova chamada vem e é idêntica a uma anterior, o valor em cache é retornado.
O arquivo config.ini contém vários parâmetros que podem ser usados para personalizar o comportamento da biblioteca, como parâmetros do modelo e nível de log. Por favor, preste atenção especial ao parâmetro API_TYPE , que define se você está usando o serviço Azure Openai ou a API OpenAI. Fornecemos um exemplo de um arquivo config.ini , ./examples/config.ini, que você pode usar como modelo para o seu próprio ou apenas modificar para executar os exemplos.
Este projeto recebe contribuições e sugestões. A maioria das contribuições exige que você concorde com um Contrato de Licença de Colaborador (CLA) declarando que você tem o direito e, na verdade, concede -nos os direitos de usar sua contribuição. Para detalhes, visite https://cla.opensource.microsoft.com.
Quando você envia uma solicitação de tração, um BOT do CLA determina automaticamente se você precisa fornecer um CLA e decorar o PR adequadamente (por exemplo, verificação de status, comentar). Simplesmente siga as instruções fornecidas pelo bot. Você só precisará fazer isso uma vez em todos os repositórios usando nosso CLA.
Este projeto adotou o Código de Conduta Open Microsoft. Para obter mais informações, consulte o Código de Conduta Perguntas frequentes ou entre em contato com [email protected] com quaisquer perguntas ou comentários adicionais.
Precisamos de todos os tipos de coisas, mas estamos buscando principalmente novas demonstrações de casos de uso interessantes, ou mesmo apenas idéias de aplicativos específicos de domínio. Se você é um especialista em domínio em alguma área que poderia se beneficiar de Tinytroupe, gostaríamos de ouvir de você.
Além disso, muitos outros aspectos podem ser melhorados, como:
Mecanismos de memória.
Mecanismos de aterramento de dados.
Mecanismos de raciocínio.
Novos tipos de ambiente.
Interface com o mundo externo.
... e mais ...
Observe que qualquer coisa que você contribua pode ser lançada como código aberto (sob licença do MIT).
Se você deseja fazer uma contribuição, tente seguir estas diretrizes gerais:
Pequena Convenção de Nomeação : Se você estiver implementando um elemento simulado voltado para o experimentador (por exemplo, um agente ou tipo de ambiente) ou intimamente relacionado (por exemplo, fábricas de agentes ou enriquecedores de conteúdo) e parece bom, chame seu novo xyz como tinyxyz :-- ), Por outro lado, os mecanismos auxiliares e de infraestrutura não devem começar com o prefixo "minúsculo". A idéia é enfatizar a natureza simulada dos elementos que fazem parte da própria simulação.
Testes: se você estiver escrevendo algum novo mecanismo, crie também pelo menos um tests/unit/ , e se puder um teste de cenário funcional ( tests/scenarios/ ).
Demonstrações: se você quiser demonstrar um novo cenário, projete -o de preferência como um novo notebook Jupyter dentro examples/ .
Microsoft: se você estiver implementando qualquer coisa que seja específica da Microsoft e não confidencial, coloque-o em uma .../microsoft/ Pasta.
O Tinytroupe começou como um projeto interno da Microsoft Hackathon e expandiu -se ao longo do tempo. A equipe principal do Tinytroupe atualmente consiste em:
Paulo Salem (criador de Tinytroupe e chumbo atual)
Christopher Olsen (Engenharia/Ciência)
Paulo Freire (Engenharia/Ciência)
Yi ding (gerenciamento de produtos)
Prérrit Saxena (Engenharia/Ciência)
Consultores atuais:
Robert Sim (Engenharia/Ciência)
Outras contribuições especiais foram feitas por:
Nilo Garcia Silveira: idéias iniciais de validação de agentes e implementação relacionada; Feedback e insights iniciais gerais; sugestões de nome.
Olnei Fonseca: Idéias iniciais de validação do agente; Feedback e insights iniciais gerais; sugestões de nomeação.
Robert Sim: cenários de geração de dados sintéticos conhecimentos e implementação.
Carlos Costa: cenários de geração de dados sintéticos conhecimentos e implementação.
Chave de Bryant: Especialização e insights de domínio do cenário de publicidade.
Barbara da Silva: implementação relacionada ao gerenciamento de memória do agente.
... você está perdendo aqui? Por favor, lembre -nos!
Estamos trabalhando em um artigo introdutório que será a citação acadêmica oficial do Tinytroupe. Enquanto isso, cite este repositório, incluindo os membros da equipe principal como autores. Por exemplo:
Paulo Salem, Christopher Olsen, Paulo Freire, Yi Ding, Prerit Saxena (2024). Tinytroupe: Simulação de persona multiagente movida a LLM para aprimoramento da imaginação e insights de negócios. [Software de computador]. Repositório do GitHub. https://github.com/microsoft/tinytroupe
Ou como Bibtex:
@misc {tinytroupe, autor = {Paulo Salem e Christopher Olsen e Paulo Freire e Yi Ding e Prerit Saxena}, Title = {Tinytroupe: LLM Multiagent Simulation para aprimoramento de imaginação e insights de negócios}, ano = {2024},, = {url {https://github.com/microsoft/tinytroupe}}, note = {repositório github}
}Tinytroupe é apenas para pesquisa e simulação. O Tinytroupe é uma tecnologia de pesquisa e experimental, que se baseia em modelos de inteligência artificial (AI) para gerar conteúdo de texto. A saída do sistema de IA pode incluir resultados irreais, inadequados, prejudiciais ou imprecisos, incluindo erros factuais. Você é responsável por revisar o conteúdo gerado (e adaptá -lo, se necessário) antes de usá -lo, pois é totalmente responsável por determinar sua precisão e adequação ao objetivo. Aconselhamos usar os resultados da Tinytroupe para a geração de insights e não para a tomada de decisão direta. Saídas geradas não refletem as opiniões da Microsoft. Você é totalmente responsável por qualquer uso que faça das saídas geradas. Para obter mais informações sobre o uso responsável dessa tecnologia, consulte o responsável_ai_faq.md.
Usos proibidos : Tinytroupe não se destina a simular situações sensíveis (por exemplo, violentas ou sexuais). Além disso, os resultados não devem ser usados para enganar deliberadamente, enganar ou prejudicar as pessoas de qualquer forma. Você é totalmente responsável por qualquer uso que faça e deve cumprir todas as leis e regulamentos aplicáveis. ”
Este projeto pode conter marcas comerciais ou logotipos para projetos, produtos ou serviços. O uso autorizado de marcas comerciais ou logotipos da Microsoft está sujeito e deve seguir as diretrizes de marca registrada e marca da Microsoft. O uso de marcas comerciais da Microsoft ou logotipos em versões modificadas deste projeto não deve causar confusão ou implicar o patrocínio da Microsoft. Qualquer uso de marcas comerciais ou logotipos de terceiros estão sujeitas às políticas de terceiros.
