Código em Python, para gerar todas as combinações em binário de um certo número de dígitos.
Para transformar um número em binário, a função binary_repr do numpy é uma alternativa.
Basta percorrer todos os números num range de 0 a 2^Ndigitos.
import numpy as np
ndig = 3
binComb =[np.binary_repr(c,ndig) for c in range(2**ndig)]
print(binComb)
Resultado:
[‘000’, ‘001’, ‘010’, ‘011’, ‘100’, ‘101’, ‘110’, ‘111’]
O artigo do link a seguir é interessante.
As redes neurais do mundo atual evoluíram tremendamente, ao ponto de conseguir reconhecer padrões. Porém, ainda são completamente ineficientes (comparada ao cérebro humano).
Imagino que há ainda muito campo a evoluir. Será necessário repensar os métodos e definições das redes atuais, para dar um novo salto.
Vi o puzzle a seguir, e parecia interessante. Por falta de um nome melhor, chamá-lo-ei de “quadrado mágico esburacado”.
Se o leitor quiser tentar resolver, aviso que há spoilers à frente.
Como eu já tinha feito uma rotina que resolve quadrados mágicos de qualquer tamanho, achei que poderia aproveitar algum padrão já existente.
Vide https://asgunzi.github.io/QuadradoMagicoD3/index.html
Entretanto, não foi possível partir para uma solução que utilizasse quadrados mágicos comuns. E também não consegui chegar numa fórmula matemática fechada, que chegue a uma solução.
O jeito foi apelar para os computadores. Mesmo assim, não é tarefa fácil.
O jeito “força bruta” pura chega a 20! (fatorial) combinações. Isso dá o número astronômico de 2,4*10^18 combinações. Computador algum no mundo consegue resolver.
O que fiz foi usar a estrutura do problema para diminuir drasticamente o número de combinações. Uma “força bruta” refinada…
Imagine fatiar o problema. Resolver somente a primeira linha.
Se olhar…
Ver o post original 364 mais palavras
O Python tem um pacote muito útil para gerar permutações.
import itertools
permutacoes = list(itertools.permutations([0,1,2]))
print(permutacoes)
O resultado é uma lista. Cada tuplas é uma permutação.
[(0, 1, 2), (0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1), (2, 1, 0)]
Note que são 3! permutações.
Em Python, math.factorial(3) = 6.
Ou seja, a cautela aqui é que o número pode crescer exponencialmente.
Por exemplo, 10! = 3.628.800
Veja também:
Em 2006, fiz a cadeira de Redes Neurais da UFRJ, como parte do meu mestrado em Processamento Digital de Sinais, motivado pelas tais redes que imitavam o cérebro humano, aprendiam sozinhas e que poderiam nos superar um dia.
Achei decepcionante, na época. As redes pareciam mais uma curiosidade, com pouca aplicação prática, do que algo realmente útil.
Alguns motivos:
– Só conseguíamos criar redes de três, cinco camadas, com poucos neurônios por camada (shallow network)
– Aplicações restritas à interpolação de funções
– O software Estatística tinha algo pronto para redes pequenas. Qualquer aplicação mais complexa, seria necessário pegar toda a matemática e implementar do zero.
Os resultados frios e estéreis eram porque, em 2006, eu estava em pleno “Inverno da Inteligência Artificial”.
Contudo, 10 anos depois, o campo era quente e fértil de inovações: redes de centenas de camadas (daí o termo deep neural network), milhares de neurônios por…
Ver o post original 1.411 mais palavras
Exemplo de modelo abstrato no Pyomo.
Link para download.
A grande vantagem é que separa claramente os dados do modelo.
Uma desvantagem é que o formato de dados tem que carregar os índices das matrizes, de forma até redundante.
Portanto, creio que vale a pena para modelos grandes, onde a chance de infeasible é alta e uma organização melhor do problema se paga.
Dados do arquivo dat:
param : N : c :=
1 1
2 2;
param : M : b :=
1 1
2 2;
param a :=
1 1 3
1 2 4
2 1 2
2 2 5;
Modelo abstrato:
“””
Created on Mon Jul 13 05:48:48 2020
@author: asgun
“””
from pyomo.environ import *
model = AbstractModel()
model.N = Set()
model.M = Set()
model.c = Param(model.N)
model.a = Param(model.M, model.N)
model.b = Param(model.M)
model.x = Var(model.N, within= NonNegativeReals)
def obj_rule(model):
return sum(model.c[i]*model.x[i] for i in model.N)
model.obj = Objective(rule = obj_rule)
def con_rule(model, m):
return sum(model.a[m,i]*model.x[i] for i in model.N) >= model.b[m]
model.con = Constraint (model.M, rule = con_rule)
opt = SolverFactory(‘glpk’)
instance = model.create_instance(“Abstract_data.dat”)
results = opt.solve(instance)
instance.display()
Este é um exemplo do Pyomo, para um modelo concreto.
Porém, uma vantagem bastante grande é que os dados podem vir em listas e dicionários do Python, e as regras da função objetivo e restrições podem ser escritas como funções do Python.
Como os projetos normalmente serão de tamanho médio, eu acho este o método mais interessante, por manipular via Python o arquivo inteiro.
Projetos muito mais pesados teriam que ser resolvidos com solvers mais poderosos, como o CPLEX, e aí a coisa muda de nível – é melhor usar AIMMS ou algo mais robusto, até para fins de debug.
Link para download.
Código:
from pyomo.environ import *
N = [1,2]
M = [1,2]
c = {1:1, 2:2}
a = {(1,1):3, (1,2):4, (2,1):2, (2,2):5}
b = {1:1, 2:2}
model = ConcreteModel()
model.x = Var(N, within = NonNegativeReals)
def obj_rule(model):
return sum(c[i] + model.x[i] for i in N)
model.obj = Objective(rule = obj_rule)
def cons_1(model,m):
return sum(a[m,i]*model.x[i] for i in N) >= b[m]
model.con = Constraint(M, rule = cons_1)
opt = SolverFactory(‘cbc’) #Ou glpk
results = opt.solve(model)
print(results)
model.display()
Link para download.
Exemplo mais simples possível do Pyomo.
É um modelo concreto, que resolve
Minimizar x1 + 2*x2
s.a.
2*x1+4*x2>=1
2*x1+5*x2>=2
Código:
from pyomo.environ import *
model = ConcreteModel()
model.x1 = Var(within=NonNegativeReals)
model.x2 = Var(within=NonNegativeReals)
model.obj= Objective(expr = model.x1 + 2*model.x2, sense=minimize)
model.con1= Constraint(expr = 2model.x1 +4model.x2 >=1)
model.con2 = Constraint(expr = 2model.x1 + 5model.x2>=2)
opt = SolverFactory(‘cbc’) #Ou glpk
results = opt.solve(model)
print(results)
model.display()
Origamis são dobraduras de papel e imaginação.
Fiz uma série destes ao longo dos anos. Coloco aqui para manter a memória e a inspiração.
A foto acima é composta de diversos papéis em formato de quadrados e triângulos intertravados.
E, para fechar um castelo:
O que o ciclo de vida de cigarras exóticas tem haver com números primos?
O artigo do link fala de cigarras que vão à superfície a cada 17 anos. É um comportamento diferente, sem dúvida.
Em sua forma imatura, esses insetos passaram os últimos 17 anos no subsolo, onde se alimentaram das raízes das árvores. Mas chegou a hora de procriarem e renovarem o ciclo em uma tarefa que exigirá que cigarras imaturas, chamadas ninfas, deixem confortáveis confins subterrâneos, transformarem-se em adultos e encontrarem um companheiro. E é aí que entra o icônico zumbido, enquanto os machos tentam cortejar uma parceira com seus zangões impressionantemente estridentes.
Existe uma teoria de que este número de anos não seja aleatório, e sim, uma estratégia que derivou do eterno jogo entre predador e presa.
Note que 17 é um número primo. Ser um número primo significa que este é divisível por 1 e…
Ver o post original 211 mais palavras
