Mais

É possível usar camadas de memória em algoritmos de processamento QGIS?

É possível usar camadas de memória em algoritmos de processamento QGIS?


Estou construindo um plugin QGIS que se conecta a um banco de dados MySQL na rede local e, em seguida, adiciona um subconjunto de uma das tabelas a uma camada na memória; o subconjunto é baseado na moeda dos dados (tomando apenas a observação mais recente para cada local onde as medições são feitas). Esta camada de memória foi criada com sucesso.

No entanto, quero executar alguns algoritmos de geoprocessamento e estou tendo problemas para usar a camada na memória em qualquer um deles.

self.stationuri = "point? crs = epsg: 4326 & field = id: integer & field = {}: double & index = yes" .format (self.cb_field.currentText ()) self.vlayer = QgsVectorLayer (self.stationuri, "scratch", " memory ") se não self.vlayer.isValid (): raise Exception (" Falha ao criar camada na memória ") self.vlayer.startEditing () for i, r in enumerate (result): # Result is row-by- resultado da linha da consulta SQL # Adicionar recursos… self.vlayer.commitChanges () self.vlayer.updateExtents () # Adicionar camada ao mapa QgsMapLayerRegistry.instance (). addMapLayer (self.vlayer) # Camada adicionada com sucesso ao mapa com todos os recursos e a geometria # ABAIXO É ONDE ESTÁ APARTADO try: processing.runandload ("gdalogr: gridinvdist", self.vlayer, self.cb_field.currentText (), 2,0,0,0,0,0,0,0, ' Float32 ', Nenhum) # Nenhum = saída na memória; Recebo o mesmo erro se especificar um caminho de string e um nome de arquivo. exceto Exceção, e: aumentar e

Nenhuma exceção é levantada, mas nenhuma saída é produzida ou adicionada ao TOC, mas o seguinte registro é feito emprocessing.log:

INFO | Seg, 04 de maio de 2015 11: 28: 23 | Saída do console de execução GDAL | / bin / sh: 1: /tmp/processing/bbebe7599c83446d9c2b03a251879657/OUTPUT.tif: não encontrado | / bin / sh: 1: -zfield: não encontrado || FALHA: A fonte de dados fonte não foi especificada. | Uso: gdal_grid [--help-general] [--formats] | [-ot {Byte / Int16 / UInt16 / UInt32 / Int32 / Float32 / Float64 / | CInt16 / CInt32 / CFloat32 / CFloat64}] | [-de formato] [-co "NOME = VALOR"] | [-zfield field_name] [-z_increase boost_value] [-z_multiply multiply_value] | [-a_srs srs_def] [-spat xmin ymin xmax ymax] | [-clipsrc | WKT | fonte de dados | spat_extent] | [-clipsrcsql sql_statement] [-clipsrclayer layer] | [expressão -clipsrcwhere] | [-l layername] * [-where expression] [-sql select_statement] | [-txe xmin xmax] [-tye ymin ymax] [-outsize xsize ysize] | [-a algoritmo [: parâmetro1 = valor1] *] [-q] |  || Algoritmos e parâmetros disponíveis com seus padrões: | Distância inversa a uma potência (padrão) | invdist: power = 2.0: smoothing = 0.0: radius1 = 0.0: radius2 = 0.0: ângulo = 0.0: max_points = 0: min_points = 0: nodata = 0.0 | Média móvel | média: raio1 = 0,0: raio2 = 0,0: ângulo = 0,0: min_points = 0: nodata = 0,0 | Vizinho mais próximo | mais próximo: raio1 = 0,0: raio2 = 0,0: ângulo = 0,0: nodata = 0,0 | Várias métricas de dados | : raio1 = 0,0: raio2 = 0,0: ângulo = 0,0: min_points = 0: nodata = 0,0 | as métricas possíveis são: | mínimo | máximo | intervalo | contagem | média_distância | média_distância_pts |

A parte importante parece serFALHA: a fonte de dados de origem não foi especificada.no entantoself.vlayer.isValid () == True, então não vejo o que há de errado com minha entrada. Eu tentei substituirself.vlayercom'memória: zero'na chamada paraprocessing.runandload, mas recebo o seguinte erro impresso no console (mas não gerado):Erro: Valor de parâmetro errado: memória: zero.

Eu tenho o mesmo problema ao executar isso por meio da GUI do QGIS e usar o menu suspenso para selecionar meucoçar, arranhãocamada que está no TOC. Isso ocorre se eu especificar o raster de saída como na memória ou especificar um local no disco.

Esta questão parece semelhante, mas a solução foi adicionar a camada de memória ao TOC antes de usá-lo. Já estou fazendo isso e, no entanto, o erro persiste.

Achei que fosse um problema geral com as camadas de memória e os algoritmos de geoprocessamento QGIS, mas o seguinte funciona sem problemas:

processing.runandload ("qgis: fixeddistancebuffer", self.vlayer, 500, 5, True, "output_buffer.shp")

O que estou fazendo de errado? Por que meu conjunto de dados de origem de memória não pode "ser especificado" em alguns dos algoritmos de processamento?

EDIT: aqui está o código-fonte dogdalogr: gridinvdistse isso for útil.


Parece que as camadas de memória não podem ser usadas como entrada para scripts de processamento GDAL / OGR porque o processamento não prepara adequadamente os dados para uso com ogr2ogr. É por isso que, por exemplo, a ferramenta de buffer QGIS funciona, mas a ferramenta de buffer GDAL / OGR falha:

Vetores de buffer de algoritmo iniciando… Comando GDAL: cmd.exe / C ogr2ogr.exe "C:  Users  anita  AppData  Local  Temp  processing70e5e0852cb9456ba2e3780f8386122e  86d237c8f41443f58a230a8133172047  ponto de memória de OUTPUT277-f8133172047 = EPSbUTccGLAYER: 632778133172047 = ponto de memória de OUTPUT277230a8133172047 = 8133172047  OUTPUTccGLAYER: OUTPUT277677dccd: 677dccd: 62277dccd: 63277dccdc-dcpout226774267204222327222327723277202772027720426720422-SDPUTGLAYER? -461d-aff6-6271ded02eea} ponto? Crs = EPSG: 4326 & memoryid = {6772bccd-f55d-461d-aff6-6271ded02eea} -dialect sqlite -sql "SELECT ST_Buffer (geometria, 1000), * FROM 'ponto? Crs = EPSG: 4326 & memoryid = {6772bccd-f55d-461d-aff6-6271ded02eea} '"Saída do comando GDAL: FALHA: Incapaz de abrir a fonte de dados' point? Crs = EPSG: 4326 'com os seguintes drivers. -> JP2ECW -> OCI -> SOSI…

O processamento teria que preparar os dados de alguma forma (salvá-los em um arquivo) e, em seguida, alimentá-los para a ferramenta GDAL / OGR.

Abri um tíquete: Não é possível usar camadas de memória com ferramentas OGR


Essa é a maneira correta, conforme explicado na documentação http://docs.qgis.org/2.14/es/docs/user_manual/processing/console.html

o próximo código funciona com todos na memória, exceto o último que é carregado

MDT = caminho / mdt.tif dreno = processing.runalg ("grama: r.drain", MDT, "", (trocadilho), False, False, False, "% f,% f,% f,% f"% (xmin, xmax, ymin, ymax), 0, -1,0,00100, Nenhum) vect = processing.runalg ("grass: r.to.vect", drenar ['output'], 0, False, "% f, % f,% f,% f "% (xmin, xmax, ymin, ymax), 0, Nenhum) bu = processing.runalg (" qgis: fixeddistancebuffer ", vect ['output'], Metros_afecta, 1, False, None ) buf = bu ['OUTPUT'] bufe = QgsVectorLayer (buf, "area", "ogr") # o último carregamento da camada QgsMapLayerRegistry.instance (). addMapLayers ([bufe])

o processing.runalg retorna um dicionário neste caso bu ['OUTPUT'] OUTPUT É A CHAVE, e o valor é um caminho temporário que você pode ver a chave com processeing.alghelp ("processamento de nome") como processamento, alghelp ("grama : r.drain ")

Retorna

processing.alghelp ("grass: r.drain") ALGORITMO: r.drain - Traça um fluxo através de um modelo de elevação em um mapa raster. entrada  coordenada  vector_points  -c  -uma  -n  GRASS_REGION_PARAMETER  GRASS_REGION_CELLSIZE_PARAMETER  GRASS_SNAP_TOLERANCE_PARAMETER  GRASS_MIN_AREA_PARAMETER  saída 

neste caso, a chave é saída , tome cuidado com a letra maiúscula você deve escrever em maiúsculo ou sem maiúsculo, neste caso não maiúsculo


E que tal dar uma olhada em GDAL Virtual File Systems (http://www.gdal.org/gdal_virtual_file_systems.html)

vsimemprefixo para caminhos semelhantes a arquivos na memória ...


Por que criptografar dados na memória?

Eu vi que KeePass não apenas criptografa seu arquivo de banco de dados de senha, mas também pode criptografar as senhas que mantém na memória. Este é apenas um exemplo. Estou pensando em um novo projeto que trata de dados sensíveis / pessoais e agora me pergunto se devo criptografar os dados mantidos na memória também. Este projeto seria implementado com Java SE e um aplicativo Android adicional. Não haverá dados armazenados na nuvem ou em um servidor neste caso especial. Os dados do Android serão importados pelo aplicativo Java SE Desktop via conexão a cabo.

Mas por que isso é necessário? Os sistemas operacionais modernos não funcionam com gerenciamento de memória virtual de forma que não seja possível que processos de espaço de usuário / modo de usuário acessem outros processos de memória?

É apenas mais uma linha de defesa se houver uma vulnerabilidade do sistema operacional tornando possível o acesso à memória externa? Nesse caso, acho que seria muito mais fácil roubar o arquivo de dados e usar um keylogger para capturar a senha que o usuário digita em vez de roubar os dados por meio do acesso à memória.


Eu ensinei C ++ para alunos de graduação por cerca de dois anos e cobri a recursão. Pela minha experiência, sua pergunta e seus sentimentos são muito comum. No extremo, alguns alunos veem a recursão como difícil de entender, enquanto outros querem usá-la para praticamente tudo.

Acho que Dave resume bem: use onde for apropriado. Ou seja, use-o quando parecer natural. Quando você enfrentar um problema em que ele se encaixa bem, provavelmente o reconhecerá: parecerá que você não consegue nem mesmo encontrar uma solução iterativa. Além disso, a clareza é um aspecto importante da programação. Outras pessoas (e você também!) Devem ser capazes de ler e entender o código que você produz. Acho que é seguro dizer que os loops iterativos são mais fáceis de entender à primeira vista do que a recursão.

Não sei o quão bem você conhece programação ou ciência da computação em geral, mas sinto fortemente que não faz sentido falar sobre funções virtuais, herança ou sobre quaisquer conceitos avançados aqui. Muitas vezes comecei com o exemplo clássico de computação de números de Fibonacci. Ele se encaixa muito bem aqui, uma vez que os números de Fibonacci são definidos recursivamente. Isso é fácil de entender e não requer algum características extravagantes da linguagem. Depois que os alunos ganharam algum conhecimento básico de recursão, demos uma outra olhada em algumas funções simples que construímos anteriormente. Aqui está um exemplo:

Uma string contém um caractere $ x $?

É assim que fazíamos antes: iterar a string e ver se algum índice contém $ x $.

A questão é então, posso fazemos isso recursivamente? Claro que podemos, aqui está uma maneira:

A próxima pergunta natural é, então, devemos fazer assim? Provavelmente não. Por quê? É mais difícil de entender e mais difícil de inventar. Portanto, também está mais sujeito a erros.

As soluções para alguns problemas são expressas mais naturalmente usando recursão.

Por exemplo, suponha que você tenha uma estrutura de dados em árvore com dois tipos de nós: folhas, que armazenam um valor inteiro e ramos, que têm uma subárvore esquerda e direita em seus campos. Suponha que as folhas estejam ordenadas, de modo que o valor mais baixo esteja na folha mais à esquerda.

Suponha que a tarefa seja imprimir os valores da árvore em ordem. Um algoritmo recursivo para fazer isso é bastante natural:

Escrever código equivalente sem recursão seria muito mais difícil. Tente!

De maneira mais geral, a recursão funciona bem para algoritmos em estruturas de dados recursivas, como árvores, ou para problemas que podem ser divididos naturalmente em subproblemas. Confira, por exemplo, algoritmos de divisão e conquista.

Se você realmente deseja ver a recursão em seu ambiente mais natural, deve examinar uma linguagem de programação funcional como Haskell. Em tal linguagem, não há construção de loop, então tudo é expresso usando recursão (ou funções de ordem superior, mas essa é outra história, uma que vale a pena conhecer também).

Observe também que as linguagens de programação funcionais realizam recursão de cauda otimizada. Isso significa que eles não estabelecem um frame de pilha a menos que não precisem --- essencialmente, a recursão pode ser convertida em um loop. De uma perspectiva prática, você pode escrever código de maneira natural, mas obter o desempenho do código iterativo. Para registro, parece que os compiladores C ++ também otimizam as chamadas finais, portanto, não há sobrecarga adicional no uso da recursão em C ++.

De alguém que praticamente vive em recursão, tentarei esclarecer o assunto.

Quando você é apresentado à recursão pela primeira vez, aprende que é uma função que chama a si mesma e é basicamente demonstrada com algoritmos como travessia de árvore. Mais tarde, você descobrirá que ele é muito usado em programação funcional para linguagens como LISP e F #. Com o F # que escrevo, a maior parte do que escrevo é recursiva e correspondência de padrões.

Se você aprender mais sobre programação funcional como F #, aprenderá que as listas F # são implementadas como listas unidas, o que significa que as operações que acessam apenas o topo da lista são O (1) e o acesso ao elemento é O (n). Depois de aprender isso, você tende a percorrer os dados como lista, construindo uma nova lista na ordem inversa e, em seguida, revertendo a lista antes de retornar da função, o que é muito eficaz.

Agora, se você começar a pensar sobre isso, logo perceberá que as funções recursivas enviarão um frame de pilha toda vez que uma chamada de função for feita e pode causar um estouro de pilha. No entanto, se você construir sua função recursiva de forma que ela possa executar uma chamada final e o compilador oferecer suporte à capacidade de otimizar o código para a chamada final. ou seja, .NET OpCodes.Tailcall Field, você não causará um estouro de pilha. Neste ponto, você começa a escrever qualquer loop como uma função recursiva e qualquer decisão como uma correspondência, os dias de if e while agora são história.

Depois que você muda para IA usando backtracking em linguagens como PROLOG, tudo é recursivo. Embora isso exija pensar de uma maneira bem diferente do código imperativo, se PROLOG for a ferramenta certa para o problema, ele o livra do fardo de ter que escrever muitas linhas de código e pode reduzir drasticamente o número de erros. Veja: cliente Amzi eoTek

Para voltar à sua questão de quando usar a recursão, uma forma que vejo na programação é com hardware em uma extremidade e conceitos abstratos na outra. Quanto mais próximo do hardware está o problema, mais penso em linguagens imperativas com if e while, quanto mais abstrato o problema, mais penso em linguagens de alto nível com recursão. No entanto, se você começar a escrever código de sistema de baixo nível e tal, e quiser verificar se ele é válido, você descobrirá que soluções como provadores de teoremas são úteis, que dependem muito da recursão.

Se você olhar para Jane Street, verá que eles usam a linguagem funcional OCaml. Embora eu não tenha visto nenhum de seus códigos, ao ler sobre o que eles mencionam sobre seu código, eles estão pensando rudemente de forma recursiva.

Já que você está procurando por uma lista de usos, darei uma idéia básica do que procurar no código e uma lista de usos básicos que se baseiam principalmente no conceito de Catamorfismo, que está além do básico.

Para C ++: Se você definir uma estrutura ou classe que tenha um ponteiro para a mesma estrutura ou classe, a recursão deve ser considerada para métodos de travessia que usam os ponteiros.

O caso simples é uma lista encadeada unilateral. Você processaria a lista começando no início ou no final e, em seguida, percorreria recursivamente a lista usando os ponteiros.

Uma árvore é outro caso em que a recursão é freqüentemente usada tanto que se você ver a travessia da árvore sem recursão, você deve começar a perguntar por quê? Não é errado, mas algo que deve ser anotado nos comentários.


Tanto a quantidade de dados e o número de árvores em sua floresta ocupará o armazenamento de memória.

Para a quantidade de dados que você tem, é óbvio por que eles ocupam armazenamento - são dados, então quanto mais você tem, mais espaço eles ocupam na memória. Se o seu conjunto de dados for muito grande, você pode nem mesmo ser capaz de ler tudo na memória - pode ser necessário permanecer no disco para treinamento (não acho que o scikit suporte isso).

Para o número de árvores, cada árvore que é cultivada é treinada em um subconjunto de características aleatórias (para que a floresta possa evitar a variação e evitar que todas as árvores cresçam da mesma maneira). Uma vez que a floresta é treinada, o objeto modelo terá informações sobre cada árvore individual - seu caminho de decisão, nós de divisão, limites, etc. Estas são informações e quanto mais informações você tiver, mais armazenamento será necessário. Portanto, mais árvores = mais informações = mais uso de memória.

Existem outros fatores que determinam quanta memória o objeto modelo (a floresta treinada) ocupará, por exemplo, max_depth que define o número máximo de camadas / níveis que qualquer árvore pode atingir. Se for grande, as árvores podem crescer mais fundo e, portanto, o objeto do modelo será maior e, portanto, precisará de mais armazenamento. Isso não deve ser muito grande, para evitar overfitting.


1 resposta 1

Não, não é seguro de todo. Uma frase secreta produziria uma chave determinística, mas isso tornaria essa chave vulnerável a ataques de força bruta e de dicionário. Além disso, Fernet.generate_key () usa um CSPRNG (os.urandom ()) que tem uma fonte de aleatoriedade específica do sistema operacional e não aceita uma semente.

É possível criar chaves determinísticas, mas fortes, usando um KDF baseado em senha. A biblioteca hashlib embutida do Python oferece duas dessas funções: pbkdf2_hmac () e scrypt (). Ambos os KDFs apresentam um fator de trabalho (uma boa quantidade de recursos da CPU deve ser gasta para produzir uma chave) que torna os ataques de força bruta / dicionário praticamente impossíveis. Eu recomendo scrypt porque custa recursos de CPU, memória e paralelização, enquanto PBKDF2 consome apenas recursos de CPU.

Criação de uma chave compatível com Fernet com scrypt:

O sal deve ser longo e aleatório, embora não seja um segredo, deve ser exclusivo para cada senha. Os parâmetros n, r e p determinam o fator de trabalho (n = CPU / custo de memória, r = tamanho do bloco, p = paralelização). Esses valores podem ser aumentados dependendo do sistema operacional - o processo de derivação da chave deve levar cerca de 100 ms. Apenas a senha é um valor secreto, os valores de sal e n, r, p podem ser armazenados ou transmitidos com a chave.


Vou supor que por C1, C2, etc, você quer dizer camadas convolucionais, e por P1, P2 você quer dizer camadas agrupadas e FC significa camadas totalmente conectadas.

Podemos calcular a memória necessária para um passe para frente como este:

Se você estiver trabalhando com valores float32, siga o link fornecido acima por @Alexandru Burlacu:

Entrada: 50x50x3 = 7.500 = 7.5K

P2: 12x12x64 = 9.216 = 9,2 K & lt- Este é um problema (e minha aproximação é um palpite muito ondulado aqui). Em vez de trabalhar com 50, 25, '12 .5 ', faria mais sentido trabalhar com múltiplos de 32. Ouvi dizer que trabalhar com múltiplos de 32 também é mais eficiente do ponto de vista da memória. A razão pela qual esta é uma má ideia é que o pool 2x2 não divide o espaço corretamente, pelo que eu posso dizer. Sinta-se à vontade para me corrigir se eu estiver errado.

Saída: 1 x 10 = 10 = 0,01K (quase nada)

Memória total: 7,5 K + 80 K + 20 K + 40 K + 0,5 K = 157,2 K * 4 bytes = 628,8 KB

Se você estiver trabalhando com um tamanho de minibatch de 64, estará lendo 64 deles na memória de uma vez e executando todas as operações juntas, ampliando tudo assim:

Entrada: 64x50x50x3 = 480.000 = 480K = 0,48M

C1: 64x50x50x32 = 5.120.000 = 5,12M

P1: 64x25x25x32 = 1.280.000 = 1.28M

C2: 64x25x25x64 = 2.560.000 = 2,56M

P2: 64x12x12x64 = 589.824 = 590K = 0,59M

FC: 64x500 = 32.000 = 32K = 0,032M

Saída: 1x10x64 = 640 = 0,64 K = 0,00064M (não nos importamos, isso é minúsculo)

Memória total: 10M x 4 bytes

40 MB (estou dizendo aproximado porque o site também informa um valor aproximado)

EDIT: Eu li errado o site, desculpe.

De acordo com o site, um passe para trás requer cerca de triplicar isso, devido à necessidade de armazenar:

as ativações e gradientes associados para cada neurônio - estes são de tamanho igual

os gradientes dos pesos (parâmetros) que são do mesmo tamanho que os parâmetros


Introdução

As mudanças de clima, erosão ambiental, desastres naturais e cargas crescentes de tráfego podem modificar continuamente o comportamento e até mesmo causar a deterioração das pontes em seu serviço de longo prazo [1]. A aplicação do BHM foi reconhecida como uma ferramenta atraente para melhorar a saúde e a segurança da ponte e fornecer um alerta precoce sobre danos à estrutura [2,3,4]. Um sistema BHM típico geralmente fornece várias informações eficazes em tempo real, como temperatura, vento, rachadura, deflexão e tensão. Podemos usar essas informações para avaliar o estado de saúde da ponte de acordo com o método de diagnóstico correspondente. Assim, o monitoramento da integridade da ponte e a avaliação da segurança são requisitos inevitáveis ​​para o desenvolvimento sustentável da engenharia da ponte.

Sabemos que a eficiência de detecção dos sensores instalados na construção da ponte se deteriora gradualmente durante sua operação de longo prazo, o que afeta a confiabilidade dos dados de monitoramento. Além disso, as severas condições ambientais têm um sério impacto na qualidade dos dados coletados [2]. Além disso, os tipos de dados coletados são diferentes e sua quantidade é enorme. Portanto, a dificuldade para a pesquisa atual e a aplicação do sistema de monitoramento da integridade da ponte muitas vezes não é coletar os dados de monitoramento, mas como extrair informações úteis dos enormes dados acumulados ao longo do tempo [5]. No entanto, a maioria dos sistemas de gerenciamento de ponte atualmente usa os dados coletados dos sensores sem análise, o que afetará muito a qualidade dos dados e fará com que a identificação de danos à estrutura da ponte e a tecnologia de diagnóstico de falhas caiam em um dilema de “desastre de dados”. O objetivo deste artigo é usar métodos baseados em mineração de dados para superar os problemas de subjetividade, alta complexidade computacional, baixa sensibilidade e tecnologia complicada na análise tradicional.

Com o trabalho ininterrupto do sistema de aquisição de dados de monitoramento de ponte, uma grande quantidade de dados é transmitida e armazenada no banco de dados todos os dias. Portanto, os dados acumulados no banco de dados podem ser considerados massivos durante todo o período de operação da ponte. A tecnologia de banco de dados tradicional mostrou sua fraqueza em lidar com uma grande quantidade de armazenamento e processamento de dados. O surgimento de tecnologia como o Hadoop oferece uma excelente solução para o processamento massivo de dados.

O processamento de dados é um componente central do sistema de monitoramento de integridade da ponte. Dados de alta qualidade são a base para julgar com precisão o estado de saúde das pontes. Com a escala crescente de dados de monitoramento de ponte, a tecnologia de banco de dados tradicional enfraqueceu gradualmente no armazenamento e processamento de dados. Para enfrentar os desafios trazidos pelo crescimento de dados no sistema de monitoramento de ponte, a função de previsão e monitoramento de dados de ponte combinada com o Hadoop tem significado teórico e valor prático. Neste trabalho, construímos um cluster Hadoop de nó triplo e testamos o algoritmo proposto em um ambiente distribuído.

Neste artigo, nos concentramos no processamento dos dados de monitoramento, bem como na obtenção de dados estruturados. E então, com base na teoria de mineração de dados de clustering, usamos a rede neural de Kohonen para agrupar os dados estruturados e explicar o ponto em clusters. Também estabelecemos um modelo de rede LSTM para prever a deflexão que pode refletir a integridade da estrutura da ponte, analisando os dados históricos de monitoramento. Esses dois métodos podem ser usados ​​para avaliar o estado de saúde das pontes em algum grau. O primeiro pode obter o padrão de classificação dos dados coletados em condições normais de operação e, em seguida, fornecer um aviso prévio correspondente por meio da análise de outliers gerados quando novos dados foram inseridos na rede.

Este último pode prever o valor de um atributo específico e, então, podemos obter o status de integridade comparando o valor previsto com seu valor limitado em operação normal. Em resumo, a rede neural de Kohonen pode fazer uma avaliação geral da estrutura geral das pontes e a rede neural LSTM pode prever o valor de um parâmetro de ponte específico. Essas duas abordagens têm sua própria ênfase, mas também podem avaliar a integridade das pontes. A principal contribuição e trabalho são os seguintes:

Nós pré-processamos os dados coletados pelos sensores do sistema de monitoramento de integridade da ponte. Em primeiro lugar, preenchemos os valores em falta, analisando a gama de valores dos dados, bem como os dados históricos e os dados empíricos. Em segundo lugar, analisamos a causa dos dados anormais e os reparamos. Por fim, mesclamos os dados que estão mais próximos no tempo de aquisição e padronizamos cada registro.

Usamos a rede neural de Kohonen para agrupar de forma auto-adaptativa os dados estruturados processados ​​e obter o padrão de classificação dos dados coletados em condições operacionais normais. Em seguida, podemos analisar os outliers gerados quando novos dados foram inseridos na rede e fornecer um aviso prévio correspondente de acordo com os resultados.

Usamos o modelo de previsão de série temporal estabelecido pela rede neural LSTM para prever o valor de deflexão. E então podemos obter o estado de saúde comparando o valor previsto com seu valor limite em operação normal.


5 respostas 5

Grandes números são usados ​​em desafios de código porque são difíceis de lidar, pelo mesmo motivo pelo qual são usados ​​para criptografia. Existem classes BigInt para a maioria das linguagens que podem ajudar a torná-las mais gerenciáveis. A maioria dos desafios de código pode ser resolvida enquanto se lida minimamente com grandes números, porém, existem soluções inteligentes que encontram maneiras de evitar ter que trabalhar com grandes números até que seja absolutamente necessário.

Embora a solução exata dependa do problema real, existem várias abordagens que você pode tentar adotar antes de simplesmente calcular em força bruta usando um arbitrário ou múltiplo biblioteca de matemática de precisão (BigInt, GMP, MPFR, ARPREC, etc.).

Primeiro, use um pouco de matemática. As expressões podem ser simplificadas? Você disse que a fonte dessas tarefas envolve quebra-cabeças, então eu estaria muito inclinado a olhar para essa abordagem para uma solução, pois isso pode ser um fator nos quebra-cabeças. aha momento. Equações com fatoriais, como probabilidades binomiais, geralmente podem ser simplificadas ou calculadas (indiretamente) usando técnicas matemáticas em vez de força bruta.

Fatorar os números e cancelar os fatores comuns seria uma das primeiras coisas que eu tentaria, manualmente, se necessário. Uma calculadora de precisão múltipla pode ser útil.

Reenquadraria a questão ou seus valores em uma base diferente (por exemplo, binária, hexadecimal) ou em uma escala de diferença (por exemplo, base logarítmica 2, 10 ou e -- natural) tornam os valores mais fáceis de lidar? Um exemplo de escala logarítmica é o decibel, usado para RF e níveis de áudio.

Usar técnicas não tão comumente ensinadas hoje em dia, mas bem conhecidas entre programadores, engenheiros, matemáticos que estão familiarizados com a régua de cálculo pode às vezes ser útil.

Dependendo da pergunta, fazer uma aproximação primeiro às vezes pode levá-lo à resposta correta, evitando que as minúcias o distraiam de atacar o problema de forma criativa.

Para seu exemplo, calcule uma equação relacionada (aproximada), mas simplificada.

que está muito perto da resposta correta ou exata

Outro "truque" é usar módulo (mod,%, modulo, a bmod n) que é uma das minhas maneiras favoritas de reduzir números, então, se você conhece alguma álgebra abstrata básica, às vezes pode trabalhar com aritmética modular.

Esse é um guia improvisado e muito aproximado de como eu abordaria uma equação "quebra-cabeça" ou um problema de programação que envolva grandes números.


5 respostas 5

Ele me disse que existem apenas duas criptografias que ele conhece que não podem ser quebradas, e AES não é uma delas

Isso me diz que você fez a pergunta errada ao seu professor. Você perguntou a um especialista em segurança cibernética se um algoritmo poderia ser quebrado, para o qual a resposta é sempre sim, com exceção de alguns algoritmos inconvenientes, como One Time Use Pads usados ​​exatamente da maneira correta. Mesmo nesses casos, há exploits com que se preocupar.

AES-256 é um algoritmo. Ele pode ser quebrado. Se você olhar para a história da criptografia, todos os algoritmos acabam quebrados. É por isso que fazemos novos algoritmos. A questão é quanto tempo leva para descobrir a matemática para quebrá-lo.

A verdadeira questão a fazer é "qual é o seu modelo de ameaça?" Que tipo de ataque você está tentando evitar? Você está criando um cadeado digital em um diário para mantê-lo protegido dos olhos curiosos de sua irmã, ou você é Edward Snowden, fugindo de várias agências de três cartas com bilhões de dólares de financiamento?

O AES-256 é atualmente classificado como suficiente para uso no governo dos EUA para a transmissão de informações TOP SECRET / SCI. Esse é o nível de classificação mais alto para o qual eles poderiam liberá-lo, então o governo dos EUA está bastante confiante de que ninguém pode quebrar o AES-256 nos prazos exigidos para proteger os maiores segredos de nossa nação.

(Bem, quase. O que realmente diz é que eles estão confiantes de que ninguém fora do governo dos EUA pode quebrar AES-256. O que você acredita que isso diz sobre se o próprio governo dos EUA pode quebrá-lo depende do seu modelo de ameaça. e se você se envolve em discussões sobre se folhas de estanho resistentes fazem chapéus melhores ou não)

AES-256 - a cifra de bloco - até onde sabemos não foi quebrada. Nem sequer esteve perto de quebrar. Por outro lado, não podemos provar que é seguro. Isso significa que um algoritmo capaz de quebrar o AES pode ser encontrado. A maioria das cifras não pode ser provado para ser seguro. Apenas alguns algoritmos, como o one-time-pad, são seguros no sentido teórico da informação.

O artigo que você aponta é sobre ataques-chave relacionados. Esses ataques são realmente possíveis e reduzem a força do AES para casos de uso específicos a um valor que teoricamente quebra a cifra. Basicamente, você não deve usar AES-256 para construir uma função hash. Praticamente, para atingir a confidencialidade, o AES-256 ainda é considerado seguro, mesmo contra ataques por criptoanálise quântica.

No entanto, ter uma cifra de bloco seguro não fornece nenhuma segurança por conta própria. Você precisa de um sistema seguro e, para esse sistema seguro, você poderia precisa de um protocolo seguro. E nesse protocolo você poderia precisa de um esquema ou modo de operação (como GCM). E esse esquema de criptografia pode exigir uma cifra de bloco. E essa cifra de bloco pode ser AES-256.

O próprio algoritmo AES-256 requer uma chave secreta bem protegida e implementação segura - como proteção contra ataques de canal lateral, quando necessário - para ser considerado seguro. Ele poderia, por exemplo, ser compatível com FIPS.

Embora o algoritmo AES-256 seja considerado seguro, isso não significa que seu esquema, protocolo ou sistema seja seguro. Para isso, você precisa de um modelo de ameaça e mostrar que é praticamente seguro contra todos os vetores de ataque possíveis.

TLDR: ao construir um sistema seguro você pode usar AES-256, é considerado seguro mesmo que isso não possa ser provado. Outros aspectos do sistema têm muito mais probabilidade de falhar do que o AES-256 - a cifra de bloco por si só.


1 resposta 1

  1. A propagação do número de itens na mochila não leva a soluções ótimas.
  2. Um solução consiste em adicionar uma terceira dimensão. Isso é bastante simples, mas é necessário levar alguns fatos em consideração ao fazê-lo. Observe, no entanto, que não é a única alternativa

A seguir, presumo que você esteja familiarizado com a solução baseada em programação dinâmica. Em particular, Não vou discutir como percorrer a tabela para trás para determinar a solução.

Vamos primeiro nos concentrar no caso típico: o número de itens é irrestrito. Neste caso, você acabou de construir uma mesa $ T $ onde $ T_$ contém o valor ideal quando a capacidade total da mochila é igual a $ i $ e apenas os primeiros $ j $ itens são considerados. Daqui:

onde $ w_j $ e $ v_j $ representam o peso e o valor do $ j $ -ésimo item, respectivamente. Se $ C $ é a capacidade total de sua mochila e há no total $ N $ itens, a solução ótima é dada por $ T_$. Esse algoritmo é conhecido por rodar em tempo pseudo-polinomial e uma de suas belezas é que ele considera apenas aquelas combinações que se enquadram na capacidade máxima.

No entanto, isso não é suficiente ao adicionar sua restrição: um número máximo de itens $ p $. O motivo é que a fórmula de recorrência anterior não leva em consideração diferentes combinações de itens:

  1. Primeiro, se $ T_& lt (T_+ v_j) $ então $ T_= (T_+ v_j) $ para que o $ j $ -ésimo item seja adicionado à mochila apesar do número máximo de itens considerados, $ p $ --- para que você possa estar violando sua restrição. Well, you might be tempted here to apply the preceding formula keeping track of the number of items inserted at each step and do not add others if the number of items currently in the knapsack exceeds $p$ but,
  2. Second, if $T_>(T_+v_j)$ then $T_=T_$ so that this item is not added but that might be a big mistake in case the optimal solution $T_$ already consists of the maximum number of items to insert into the knapsack. The reason is that we are not properly comparing: on one hand, to preserve the optimal solution consisting of $p$ items selected among the previous $(j-1)$ on the other hand, to insert the $j$-th item and, additionally consider the best subset with $(p-1)$ items among the previous $(j-1)$.

So that a first solution consists of adding a third dimension. For your case, let $T_$ be the optimal solution when the capacity of the knapsack is $i$, only the first $j$ items are considered and it is not allowed to put more than $k$ items in the knapsack. Agora,

  • If you are computing $T_$ for a number of items strictly less or equal than the number of items that can be inserted ($jleq k$) then proceed as usual but using the same value of $k$: $T_ =max<>, T_+v_j>$
  • Now, if you have to compute $T_$ for a number of items strictly larger than the number of items that can be inserted ($j> k$) then: $T_ =max<>, T_+v_j>$

The first expression should be clear. The second works since the $(k-1)$-th layer of the table $T$ keeps track of the best combination of $(k-1)$ items among the first $(j-1)$ as required above.

An efficient implementation of this algorithm does not need to compute $T_$ for all $k$. Note that the preceding recurrence relationships relate layer $k$ with $(k-1)$ and thus, it is possible to alternate between two successive layers (e.g., if you are interested in the optimal solution with $k=4$ you just use two consecutive layers: 0 and 1, 1 and 2, 2 and 3, 3 and 4 and you're done). In other words, this algorithm takes twice the memory required by the traditional approach based on dynamic programming and thus, it can be still run in pseudo-polynomial time.

Be aware, however, that this is not the only solution! And there is another you might find more elegant. In the preceding formulae, we retrieved the optimal solution which consisted of no more than $(k-1)$ items among the first $(j-1)$ as $T_$. However, it should be clear that this is precisely equal to $maxlimits_<>>$ just by using the original table!! ie., the optimal solution with no more than $k$ items can be also retrieved by considering the optimal solutions with 1 item, 2 items, 3 items, . $(j-1)$ items . To make this formulation work you should also keep track of the number of items considered in every partial solution so that you will need two integers per cell. This memory occupation results in precisely the same memory requirements of the algorithm shown above (using a third dimension in the form of layers $k$).


Assista o vídeo: Lekcja #33. Generalizacja warstwy wektorowej. Tutorial QGIS. Trener GIS. Kurs QGIS