Geração procedural com computação quântica





Hoje analisaremos o discurso de James Wootton, da IBM Quantum, na conferência FDG 2020. Falaremos sobre computação quântica - uma tecnologia potencialmente promissora, para a qual, entretanto, há pouca aplicação no estágio atual de desenvolvimento. E ainda um deles foi encontrado na geração procedural.



Vamos falar mais detalhadamente sobre como implementá-lo nos qubits e também fornecer os códigos do programa.









Vamos começar com o que os computadores quânticos são e como eles podem ser potencialmente úteis. Não vamos nos aprofundar nos detalhes técnicos. Só para mencionar que os computadores quânticos são um modelo de computação completamente diferente dos computadores digitais e analógicos. Eles não apenas aceleram o software convencional com quanta. Em vez disso, eles exigem uma abordagem completamente diferente para a implementação de programas, bem como um hardware diferente para executá-los.







A computação quântica um dia será capaz de realizar certas tarefas com muito mais eficiência do que a computação digital ou analógica. Isso nos permitirá lidar com problemas que atualmente são impossíveis de resolver. Após décadas de pesquisa, muitos algoritmos quânticos foram identificados que demonstram de forma mais eficaz essas vantagens em relação a uma série de aplicações possíveis - incluindo no campo da geração procedural. Isso inclui problemas de otimização, satisfação de restrição, análise de gráfico e outros.



Construir computadores capazes de realizar computação quântica é uma tarefa assustadora por si só, e tem estado em construção há anos. Um dos parâmetros importantes para descrever um dispositivo quântico é o número de qubits. Na verdade, esses são os mesmos bits, mas implementados de forma quântica - e, portanto, tendo mais estados do que os normais 0 e 1. No contexto da física quântica, podemos escrever os valores dos bits usando um par de vetores ortogonais: | 0⟩ e | 1⟩. No caso de qubits, a descrição dos estados será suplementado com amplitudes complexas c 0 e c 1 , que satisfazem a condição de: | c 0 | 2 + | c 1 | 2= 1, devido ao qual um maior número de estados do qubit c 0 | 0⟩ + c 1 | 1⟩ é alcançado.







Precisamos de muitos milhares de qubits para executar os algoritmos principais, que não teremos nos próximos anos.



Atualmente não temos muitos milhares de qubits ou mesmo mil à nossa disposição. Para ser honesto, não temos nem cem qubits. O maior dispositivo disponível atualmente para nós tem 65 qubits. Embora isso não seja suficiente para executar os algoritmos mais interessantes e eficientes que conhecemos, mesmo esse número de qubits pode fornecer resultados que não são esperados de computadores convencionais. Isso é evidenciado pela complexidade de emular esses dispositivos, para os quais você precisará alugar o maior supercomputador do mundo.



Portanto, o hardware quântico pode nos oferecer respostas únicas, mas ao longo das décadas não aprendemos como fazer as perguntas certas. Portanto, o principal objetivo de nossa pesquisa atual é tentar descobrir o mais rápido possível como fazer algo útil com essas máquinas.







Existem também dispositivos de potência mais modesta, consistindo em cerca de 20 qubits. E programas quânticos usando até 15 qubits foram disponibilizados pela IBM gratuitamente. Além disso, eles criaram um software de emulação para auxiliar no projeto e teste de programas quânticos. E embora emular mais de 50 qubits seja uma tarefa computacional assustadora, até mesmo o seu laptop pode emular cerca de 20 qubits sem problemas.



Todos os fatores juntos fazem de 20 qubits um marco. Independentemente de estarmos usando hardware quântico real ou sua emulação, executar software quântico desse nível não é muito difícil.







Então, o que tudo isso significa para a geração procedural? Depende de qual das três eras você está almejando: a de hoje, pronta para fornecer apenas dezenas de qubits; para o futuro próximo, quando os dispositivos terão centenas de qubits; ou para um futuro distante, quando mais de mil qubits estarão disponíveis para nós.



Se falamos de hoje, o software quântico, focado no poder de apenas 20 qubits, ainda não pode fazer nada de único. O próprio fato de podermos executá-lo em um emulador significa que você nem mesmo precisa de hardware quântico. Mas os programas quânticos ainda podem fazer algo útil? Podemos escrever um programa quântico de 20 qubit que produza resultados úteis para o usuário final real?



Se conseguirmos obter resultados realmente úteis com 20 qubits, esse efeito só se multiplicará com o tempo e com mais poder de computação. A era do meio será a era da pesquisa de métodos cada vez mais sofisticados de computação quântica, inclusive eficazes para geração procedural. Seguiremos para a criação de ferramentas nas quais provavelmente não teríamos pensado se não tivéssemos pensado em termos de quanta.



Mas não vamos nos precipitar. O primeiro passo em direção à era da expansão da utilidade é provar que mesmo o software quântico de 20 qubit pode ser útil. Isso é o que faremos.







Agora é hora de esclarecer alguns detalhes.



Geração processual significa que precisamos gerar algo. Mas o que?



A geração do terreno é a mais óbvia, então vamos começar com isso.



O ruído de Perlin é uma ferramenta onipresente para geração de terreno procedural. Mas existe outro método, muito menos complicado de criá-lo - usando um conjunto de pontos aleatórios com seu subsequente desfoque. A implementação de algo assim nos pareceu uma meta mais alcançável para o primeiro passo, então a tomaremos como base.



Vamos começar desenvolvendo uma maneira de codificar mapas de altura na forma de circuitos quânticos, que são elementos fundamentais do software quântico. Eles têm alguma semelhança com os modelos de circuitos booleanos para computação digital. Qubits são essencialmente os mesmos bits que sofrem alterações diferentes conforme os cálculos são executados.







Trabalharemos com imagens em preto e branco, onde o brilho do pixel pode ter um valor de 0 a 1. Da mesma forma, podem ser confundidos com mapas de altura. Depois de aprendermos como codificar esses mapas de altura como esquemas, podemos gerenciá-los. A codificação usada visa comprimir tantos pontos quanto possível em tão poucos qubits quanto possível. Este método não deixa muita flexibilidade para fornecer controle conveniente e flexível. Ao mesmo tempo, quase qualquer mudança no circuito causará efeitos de interferência.



Usamos principalmente operações que podem ser vistas como formas parciais da porta NOT. Quando aplicado a bits normais, NÃO mude o valor de 0 para 1 e vice-versa. Com a ajuda de portas quânticas, podemos parametrizar este elemento para realizar uma operação que pode fazer metade de NOT, ou um quarto, ou qualquer outra parte fracionária que pode ser representada por um conjunto de 2 n amplitudes de n qubits.



A função abaixo converte a imagem original em um circuito quântico:



def height2circuit(height):
#   
L = max(max(height))+1
#  
grid = make_grid(L)
#    
n = 2*int(np.ceil(np.log(L)/np.log(2)))
#   
state = [0]*(2**n)
#    
H = 0
for bit string in grid:
(x,y) = grid[bit string]
if (x,y) in height:
h = height[x,y]
state[ int(bit string,2) ] = np.sqrt( h )
H += h
#  
for j,amp in enumerate(state):
state[ j ] = amp/np.sqrt(H)
#   
qc = QuantumCircuit(n,n)
qc.initialize(state,range(n))
#   Qiskit 
# qc.initialize( state, qc.qregs[0])
return qc


Então, precisamos fazer o processo oposto - transformar o circuito quântico em uma imagem:



def circuit2height(qc):
#     
n = qc.num_qubits
grid = make_grid(int(2**(n/2)))
#     
ket = qi.Statevector(qc.data[0][0].params)
qc.data.pop(0)
#        
ket = ket.evolve(qc)
#   
p = ket.probabilities_dict()
#       
max_h = max( p.values() )
#      
height = {}
for bit string in p:
if bit string in grid:
height[grid[bit string]] = p[bit string]/max_h
return height


Se aplicarmos esta operação a todos os qubits, podemos ver como o mapa de altura muda conforme a fração aumenta. Você obterá algo como um efeito de desfoque. Os efeitos de interferência ocorrerão, criando um padrão que não pode ser alcançado com um desfoque simples.



No exemplo acima em (a), começamos com um par de pontos aparentemente arbitrários. Gradualmente, eles sofrem um desfoque, após o qual efeitos de interferência são sobrepostos a eles. Isso leva ao aparecimento de um padrão - no nosso caso, como um tabuleiro de damas em (f). Este resultado específico tem uma conexão clara com os dois pixels com os quais começamos. Se tomarmos outros dados como ponto de partida, o resultado também será completamente diferente.



Quantum Blur foi desenvolvido e testado em vários game jams. É usado principalmente para gerar texturas e mapas de nível.







Depois de gerar esses mapas, nós os usamos para o análogo quântico do ruído de alta frequência de Perlin.



Portanto, agora criamos o perfil principal - por exemplo, ilhas - de alguma outra forma - como em © no nosso exemplo. Então, precisamos de um conjunto inicial de pixels como em (a). Nós o desfocamos quanticamente para gerar um padrão como (b). Depois disso, aplicamos ao perfil principal para criar a paisagem final.



Você pode ver um exemplo 2D aqui, bem como a renderização 3D que foi usada no jogo tutorial IBM QiskitBlocks. Detalhes como informações sobre o tipo de grama e a localização das árvores na renderização 3D também foram desenvolvidos usando operações quânticas.









Como as imagens RGB são normalmente três mapas de altura alinhados juntos, podemos manipular essas imagens também. Desta forma, é fácil criar algumas imagens estranhas usando sobreposição. Mais difícil, mas mais eficaz - codificar um par de imagens e criar um efeito de teletransporte entre elas.



O teletransporte quântico transfere informações entre qubits. Portanto, pegamos dois registradores qubit do mesmo tamanho e apenas mudamos seus estados. Vamos usar esta operação para criar uma animação de transição.







Uma ideia de codificação semelhante também pode ser usada para outras formas de dados. Wootton tentou usá-lo na música:





e o nível de Mario:





Aqui estão mais dois exemplos que são importantes para nós. Um deles é um estúdio de jogos usando esse método para geração procedural em um jogo futuro. O projeto tem um ambiente de ficção científica e o método quântico traz um genuíno sabor da ciência.



Além disso, a artista Libby Heaney usou algumas dessas ideias como ponto de partida para seu trabalho.





A natureza quântica da computação é destacada em ambos os casos: é importante para o usuário que os resultados venham do domínio quântico do espaço do algoritmo, e não apenas da álgebra linear brilhante.







O método descrito aqui é mais adequado para emulação do que para hardware quântico real, mas isso mudará em breve. Na verdade, um dos maiores dispositivos quânticos da IBM também foi usado para geração procedural, embora de uma maneira completamente diferente.



Enquanto isso, você pode experimentar o efeito de desfoque quântico. Ele é escrito em Python , mas também existe um plugin para o Unity . Talvez eles sejam úteis para você.



Link para o artigo completo: aqui .



All Articles