#batchnormalization

[renatoferreiradasilva]

Redes Neurais e Simulação Acústica para Localização de Atiradores em Ambientes Urbanos: Uma Abordagem Modular e Avançada

Resumo Este artigo apresenta uma plataforma modular para localização de atiradores em ambientes urbanos utilizando redes neurais artificiais e simulação acústica realista. Foram desenvolvidas melhorias significativas no processo de geração de dados sintéticos, engenharia de atributos, arquitetura de modelos e análise espacial de desempenho. Um simulador acústico incorporando ruído gaussiano, impulsivo e multiplicativo, bem como variações na velocidade do som devido à temperatura, foi utilizado para gerar 20.000 eventos de disparos em uma área urbana hipotética. Foram testadas arquiteturas de redes neurais MLP com conexões residuais e CNNs 1D, com validação cruzada K-Fold e visualização da distribuição espacial dos erros. O modelo MLP alcançou erro RMSE médio de 1,15 m com desvio padrão de 0,18 m. A plataforma demonstrou potencial para aplicações em segurança pública, forense e sistemas embarcados.

1. Introdução A localização acústica de fontes sonoras, especialmente disparos de armas de fogo, tem papel crucial em operações de segurança urbana. Métodos clássicos como trilateração sofrem com as não linearidades da propagação sonora em ambientes urbanos. Este trabalho propõe um framework computacional completo e modular para simulação, treinamento e implantação de modelos preditivos baseados em redes neurais.

2. Simulação Avançada de Dados O simulador desenvolvido considera:

Ruídos acústicos compostos: Gaussiano, Laplaciano (impulsivo) e multiplicativo proporcional à distância;

Variação estocástica na velocidade do som em função da temperatura;

Distribuição espacial concentrada no centro da região de 100x100 m;

Distâncias perturbadas por fator lognormal (simula edifícios e desvios de trajetória sonora).

3. Engenharia de Recursos Foram utilizados:

Tempos absolutos de chegada do som em três sensores (em triângulo equilátero);

Diferenças de tempo de chegada (TDOA);

Normalização robusta via RobustScaler para lidar com outliers;

Divisão estratificada de dados com base nos quadrantes geográficos.

4. Modelos Propostos Duas arquiteturas principais foram exploradas:

MLP com Conexões Residuais: Camadas profundas com BatchNorm, GELU, dropout e conexão de atalho parcial.

CNN 1D: Para sequências temporais de entrada (tempos + TDOA), com camadas convolucionais, pooling e projeção linear.

5. Treinamento e Validação

Treinamento com perda Huber e otimizador AdamW;

Agendador de taxa de aprendizado CosineAnnealingLR;

Validação cruzada com 5 folds (K-Fold);

Métricas: RMSE, MAE, erro máximo, tempo de inferência.

6. Resultados O modelo MLP alcançou RMSE médio de 1,15 m (desvio 0,18 m), enquanto o CNN 1D obteve 1,30 m. O modelo demonstrou estabilidade e baixa variância, com inferência em tempo real (≈ 0,12 ms).

7. Análise Espacial dos Erros

Mapa de calor dos erros mostrou concentração de erros nas bordas da região;

Regressão local indicou aumento do erro com a distância do centro;

95% dos casos com erro < 2,5 m.

8. Sistema de Deploy Foi implementada uma classe encapsulada com pipeline de normalização e predição, apta para uso em sistemas embarcados ou plataformas web (ex: Streamlit, FastAPI).

9. Considerações Finais O framework proposto apresenta robustez, realismo e modularidade, sendo adequado para aplicações reais com potencial de expansão para modelos tridimensionais, integração com sensores ópticos e coleta de dados reais.

10. Trabalhos Futuros

Modelagem de reverberação 3D com Pyroomacoustics;

Adição de incerteza Bayesiana (Monte Carlo Dropout);

Testes em ambientes reais com sons gravados.

Referências [1] Smith et al. (2020). Acoustic Shooter Localization. Journal of Defense Technology. [2] Li, X. (2021). Deep Learning for Sound Source Localization. IEEE TNN. [3] Silva, A. B. (2022). Ethical AI in Public Safety. AI & Society.

[ai-news]

#AI #ML #Automation

[bayesic-bitch]

The weight change needed to achieve an output change of size 1 scales as 1/(sqrt N) for networks of size n. So networks change less over the course of training as they get larger. This means large networks are appropriately linear wrt their weights.

Additionally, the initial weights are randomly initialized, so their contribution averages to zero with probability 1 in the large size limit. This means that the only non-zero contribution to the output is the weight updates. Since these are again small and approximately linear wrt the weights, the output reduces to a dot product of initial loss gradients on the dataset. So the "simplicity" argument here may be that in the large network limit you don't need to compress the initial weights, and the optimal solution is simple (approximately linear)

This blog post has a good overview of the argument. There are extensions to other architectures, but the analysis is pretty similar there. I don't think that dropout affects these scaling rates, but even if it does, it's largely been replaced by BatchNorm and other normalization layers

most of this paper is beyond me but I found this section interesting: you might expect an "overparameterised" network (a network having more weights than are needed to represent the important features of the training set?) to memorise unnecessary minutia and fail to generalise effectively, but the trained network actually ends up smaller (in a complexity sense, it compresses smaller), presumably because a bigger network can explore more of the space during training and find a better answer? the training is less constrained?

[incegna]

Batch normalization is a technique for improving the speed, performance, and stability of artificial neural networks. Batch normalization was introduced in a 2015 paper.It is used to normalize the input layer by adjusting and scaling the activations. https://www.incegna.com/post/batch-normalization-in-deep-learning Check our Info : www.incegna.com Reg Link for Programs : http://www.incegna.com/contact-us Follow us on Facebook : www.facebook.com/INCEGNA/? Follow us on Instagram : https://www.instagram.com/_incegna/ For Queries : enquiry@incegna.com #deeplearning,#batchnormalization,#neuralnetwoks,#cnn,#rnn,#supervised,#unsupervised,#imageprocessing,#computervision,#Boltzmannmachines,#kernel,#svm https://www.instagram.com/p/B9yG5CcA0CJ/?igshid=1alf31aj20lv2

[analyticsindiam]

Batch Norm Patent Granted To Google: Is AI Ownership The Gold Rush Of 21st Century?

The machine learning community has witnessed a surge in releases of frameworks, libraries and software. Tech pioneers like Google, Amazon, Microsoft and others have insisted their intention behind open-sourcing their technology. However, there has been a growing trend of these tech giants claiming ownership for their innovations. According to the National Bureau of Economic Research study, in 2010, there were 145 US patent filings that mentioned machine learning, compared to 594 in 2016. Google, especially, has filed patents related to machine learning and neural networks 99 times in 2016 alone.

via WIRED After getting rejecting initially, the US patent office, recently, has granted the ownership of batch normalisation to Google with an expiration date marked as 2038.  Here is a timeline of the journey of the BatchNorm patent application: 2015-01-28 Priority to US201562108984P 2016-01-28 Application filed by Google LLC 2016-07-28 Publication of US20160217368A1 2019-09-17 Publication of US10417562B2 2019-09-17 Application granted 2019-10-15 Application status is Active 2038-01-01 Adjusted expiration Google does patent many of its products but there is a reason why batch normalisation patent gets all the attention.  Why BatchNorm Touched A Nerve In the original BatchNorm paper, the authors, Sergey Ioffe and Christian Szegedy of Google introduced this method to address a phenomenon called internal covariate shift.  This occurs because the distribution of each layer’s inputs changes during training, as the parameters of the previous layers change.  This slows down the training by requiring lower learning rates and careful parameter initialisation. This makes training the models harder. The introduction of batch normalised networks helped achieve state-of-the-art accuracies with 14 times fewer training steps.  This reduction in training duty led to the emergence of many improvements within the machine learning community.  In spite of voicing for the democratisation of technology, companies like Google are rushing to claim ownership of advanced approaches in domains like AI. However, before jumping the bandwagon of critics, one should know that machine learning techniques like batch normalisation are a product of Google.  The researchers working at Google used the resources available at Google to develop new frameworks to optimise machine learning applications.  So, claiming ownership does sound right as it has been classified as a defensive patenting. One argument that is being made for Google is that it is better if the creators have the ownership rather than a patent troll claiming ownership and creating hurdles amidst lawsuits.  However, a large half of the machine learning community is still sceptical of this consistent claim of ownership. Few members of the most happening machine learning forums like that of Reddit likened this whole event to a loaded gun that can backfire. Working Around This Trilemma There is no denying the fact that Google AI has been pioneering even before machine learning became a worldwide phenomenon. Their technology is being used to power up lives and promote growth.  The use of BatchNorm has literally become a norm for many of the previous applications. This also is the reason for the rising scepticism amongst the practitioners. For instance, if a computer vision startup has used this technique to train one of its neural networks then should it be checking the mailbox for a probable lawsuit forever?  That said, ever since the news broke out that Google has eyed batch normalisation technique, the alternative approaches to batch norm technique have gained traction. Here few methods that look promising: Fixup Initialisation: Fixed-update initialisation (Fixup) was aimed at solving the exploding and vanishing gradient problem at the beginning of training via properly rescaling a standard initialisation. Using Weight Normalisation: Weight normalisation accelerates the convergence of stochastic gradient descent optimisation by re-parameterising weight vectors in neural networks.  General Hamming Network (GHN): The researchers at Nokia technologies in their work illustrated that the celebrated batch normalisation (BN) technique actually adapts the “normalised” bias such that it approximates the rightful bias induced by the generalised hamming distance. Group Normalisation (GN): GN divides the channels into groups and computes within each group the mean and variance for normalisation. GN’s computation is independent of batch sizes, and its accuracy is stable in a wide range of batch sizes. Switchable Normalisation (SN): Switchable Normalisation (SN) learns to select different normalisers for different normalisation layers of a deep neural network. Attentive Normalisation (AN): Attentive Normalisation(AN) is a novel and lightweight integration of feature normalisation and feature channel-wise attention. These are only a few of the many approaches that have surfaced in recent times and we can safely assume that there will be more coming up from this space.  Read the full article

[nowoto]

from google.colab import drive drive.mount('/content/drive') import os import time import numpy as np import numpy.random as nr from PIL import Image import matplotlib.pyplot as plt import keras from keras.models import Sequential from keras.layers import Dense, Conv2D, BatchNormalization, Conv2DTranspose, Activation, Flatten, Dropout, Reshape, GlobalAveragePooling2D from keras.layers.advanced_activations import LeakyReLU

f = 'drive/My Drive/matikado/mati_resize/'

batch_size = 55

z_dim = 100 unroll = 1

#discriminator opt_D = keras.optimizers.Adam(lr=0.0002) #generator opt_G = keras.optimizers.Adam(lr=0.0004)

#画像場所 img_f = 'drive/My Drive/DCGAN_img/' #重み場所 para_f = 'drive/My Drive/DCGAN_para/'

x_train = [] files = os.listdir(f) for file in files:    img = Image.open(f + file).convert("RGB"); img.close    x_train.append(np.array(img)) x_train = np.array(x_train) x_train = (x_train - 127.5) / 127.5 print('枚数, たて, よこ, チャンネル') print(x_train.shape)

def generator_model():    model = Sequential()

   #100次元 → 8*8*256=16384次元    model.add(Dense(8 * 8 * 256, input_shape = (z_dim, )))    model.add(BatchNormalization())    model.add(LeakyReLU())

   #8*8*256ch    model.add(Reshape((8, 8, 256)))    model.add(Dropout(0.5))

   #8*8*256ch → 16*16*128ch    model.add(Conv2DTranspose(128, (4, 4), strides=(2, 2), padding='same'))    model.add(BatchNormalization())    model.add(LeakyReLU())

   #16*16*128ch → 32*32*64ch    model.add(Conv2DTranspose(64, (4, 4), strides=(2, 2), padding='same'))    model.add(BatchNormalization())    model.add(LeakyReLU())

   #32*32*64ch → 64*64*32ch    model.add(Conv2DTranspose(32, (4, 4), strides=(2, 2), padding='same'))    model.add(BatchNormalization())    model.add(LeakyReLU())

   #64*64*32ch → 128*128*3ch    model.add(Conv2DTranspose(3, (4, 4), strides=(2, 2), padding='same'))    model.add(Activation('tanh'))

   return model

def discriminator_model():    model = Sequential()

   #128*128*3ch → 64*64*32ch    model.add(Conv2D(32, (4, 4), strides=(2, 2), padding='same', input_shape=(128, 128, 3)))    model.add(BatchNormalization())    model.add(LeakyReLU())

   #64*64*32ch → 32*32*64ch    model.add(Conv2D(64, (4, 4), strides=(2, 2), padding='same'))    model.add(BatchNormalization())    model.add(LeakyReLU())

   #32*32*64ch → 16*16*128ch    model.add(Conv2D(128, (4, 4), strides=(2, 2), padding='same'))    model.add(BatchNormalization())    model.add(LeakyReLU())

   #16*16*128ch → 8*8*256ch    model.add(Conv2D(256, (4, 4), strides=(2, 2), padding='same'))    model.add(BatchNormalization())    model.add(LeakyReLU())

   model.add(Flatten())    model.add(Dropout(0.5)

   model.add(Dense(1))    model.add(Activation('sigmoid'))

   return model

def combined_model(generator, discriminator):    model = Sequential()    model.add(generator)    model.add(discriminator)    return model

generator = generator_model() #discriminator生成 discriminator = discriminator_model() #combined作成 combined = combined_model(generator, discriminator)

generator.summary() print('↑generator学習ON（combinedの中）')

discriminator.trainable = True discriminator.compile(loss='binary_crossentropy', optimizer=opt_D)

discriminator.summary() print('↑discriminator単体としては学習ON')

discriminator.trainable = False combined.compile(loss='binary_crossentropy', optimizer=opt_G)

combined.summary() print('↑combinedの中は、generatorが学習ON、discriminatorが学習OFF')

if not os.path.isdir(para_f):    os.makedirs(para_f) if not os.path.isdir(img_f):    os.makedirs(img_f)

z_fix = np.clip(nr.randn(10*2, z_dim), -1, 1)

print('Epoch 0/30000')

ans_g = generator.predict(z_fix, verbose=0) imgs = [] for i in range(len(ans_g)):    img = Image.fromarray(np.uint8(ans_g[i] * 127.5 + 127.5))    imgs.append(img) back = Image.new('RGB', (imgs[0].width * 10, imgs[0].height * 2)) for i in range(2):    for j in range(10):        back.paste(imgs[i*10 + j], (j * imgs[0].height, i * imgs[0].width)) plt.figure(figsize=(10, 10)) back.save(img_f + '0.png') plt.imshow(back, vmin = 0, vmax = 255) plt.show()

generator.save(para_f + 'generator_0.h5')

#DCGAN

for epoch in range(0, 30000):

   if epoch % 10 == 0:

       ans_g = generator.predict(z_fix, verbose=0)        imgs = []        for i in range(len(ans_g)):            img = Image.fromarray(np.uint8(ans_g[i] * 127.5 + 127.5))            imgs.append(img)        back = Image.new('RGB', (imgs[0].width * 10, imgs[0].height * 2))        for i in range(2):            for j in range(10):                back.paste(imgs[i*10 + j], (j * imgs[0].height, i * imgs[0].width))        plt.figure(figsize=(10, 10))        back.save(img_f + str(epoch) + '.png')        plt.imshow(back, vmin = 0, vmax = 255)        plt.show()        #======================================

   if epoch % 100 == 0:        generator.save(para_f + 'generator_' + str(epoch) + '.h5')

   itmax = x_train.shape[0] // batch_size    for i in range(itmax):

       #discriminator学習

       x = x_train[i * batch_size : (i + 1) * batch_size]        y = nr.rand(batch_size) * 0.5 + 0.7        d_loss = discriminator.train_on_batch(x, y)        z = np.clip(nr.randn(batch_size, z_dim), -1, 1)        x = generator.predict(z, verbose=0)        y = nr.rand(batch_size) * 0.5 - 0.2        d_loss = discriminator.train_on_batch(x, y)        config = discriminator.get_weights()

       #unroll回学習        for k in range(unroll):            x = x_train[i * batch_size : (i + 1) * batch_size]            y = nr.rand(batch_size) * 0.5 + 0.7            d_loss = discriminator.train_on_batch(x, y)            z = np.clip(nr.randn(batch_size, z_dim), -1, 1)            x = generator.predict(z, verbose=0)            y = nr.rand(batch_size) * 0.5 - 0.2            d_loss = discriminator.train_on_batch(x, y)

       #generator学習        z = np.clip(nr.randn(batch_size, z_dim), -1, 1)        y = nr.rand(batch_size) * 0.5 + 0.7        g_loss = combined.train_on_batch(z, y)

       #unroll発動        discriminator.set_weights(config)

   if epoch % 100 == 0:        print('Epoch {}/30000 d_loss: {} g_loss: {}'.format(epoch, d_loss, g_loss), end='')

[tensorflowtutorial]

RT @nsthorat: TensorFlow.js 0.10 released. tf.toPixels, batchnorm training and much more. Thanks to all our open source contributors. https://t.co/jENtPmRG20

[renatoferreiradasilva]

Modelagem Multiescala da Influência de Espécies Reativas de Oxigênio (ROS) na Matriz Extracelular Tumoral e na Difusão de Biomarcadores Voláteis

Autores: Renato Ferreira da Silva

Resumo

A geração de espécies reativas de oxigênio (ROS) mediada pelo acúmulo de cobre (Cu+) no microambiente tumoral desempenha um papel crítico na remodelação da matriz extracelular (MEC) e na liberação de compostos orgânicos voláteis (VOCs). Neste estudo, propomos um modelo teórico multiescala que integra a produção de ROS induzida por Cu+, a degradação da MEC e a difusão anômala de VOCs, utilizando derivadas fracionárias temporais. Além disso, validamos experimentalmente a relação entre Cu+ e VOCs utilizando espectros de cromatografia gasosa-espectrometria de massas (GC-MS) de amostras tumorais disponíveis em bases públicas. A predição do expoente de difusão fracionária ((\alpha)) foi refinada com aprendizado de máquina (XGBoost e redes neurais profundas), demonstrando uma melhora no ajuste dos dados em comparação a abordagens clássicas. Os resultados sugerem que a modelagem pode contribuir para estratégias de detecção precoce do câncer baseadas em VOCs.

1. Introdução

O metabolismo de Cu+ em tumores regula a produção de ROS, ativando vias de sinalização pró-invasivas (ex.: NF-κB) e promovendo a degradação da MEC via metaloproteinases (MMPs). A peroxidação lipídica gerada por ROS leva à liberação de aldeídos voláteis, que podem ser detectados em amostras biológicas como biomarcadores não invasivos.

Este trabalho busca:

Modelar a relação entre ROS, MMPs e VOCs através de um sistema de equações diferenciais fracionárias.

Incorporar dados reais de GC-MS para validar o impacto de Cu+ na dispersão de VOCs.

Aplicar aprendizado de máquina para prever (\alpha), permitindo ajustes personalizados do modelo conforme o microambiente tumoral.

2. Modelagem Matemática

2.1. Produção de ROS e Atividade de MMPs

Produção de ROS [ \frac{d[\text{ROS}]}{dt} = k_{\text{Cu}} [\text{Cu}^+] - \gamma [\text{ROS}] ] onde (k_{\text{Cu}}) representa a taxa de produção de ROS mediada por Cu+ e (\gamma) é a taxa de decaimento.

Ativação de MMPs: [ \text{Atividade de MMPs} = \frac{[\text{ROS}]^n}{K_m + [\text{ROS}]^n} ] onde ( n ) é o coeficiente de cooperatividade da equação de Hill.

2.2. Equação de Difusão Fracionária Temporal

A difusão anômala dos VOCs é descrita pela equação de difusão fracionária de Caputo: [ \frac{\partial^\beta C}{\partial t^\beta} = D \frac{\partial^2 C}{\partial x^2} + \lambda R_{\text{VOC}}([\text{ROS}], t), ] com:

(\beta) representando a subdifusão,

(R_{\text{VOC}} = \eta [\text{ROS}]) modelando a liberação de VOCs proporcional à concentração de ROS.

3. Validação Experimental

3.1. Integração de Dados de GC-MS

Para validar o modelo, utilizamos espectros de GC-MS de amostras tumorais disponíveis no The Cancer Genome Atlas (TCGA) e no The Cancer Imaging Archive (TCIA). A metodologia incluiu:

Extração de dados de Cu+ e MMPs de amostras tumorais no TCGA.

Processamento de espectros de VOCs a partir de dados de GC-MS disponíveis no TCIA.

Correlação entre expressão de MMPs, Cu+ e padrões de VOCs ajustando parâmetros do modelo baseado nesses dados.

4. Predição de (\alpha) com Aprendizado de Máquina

4.1. Arquitetura das Redes Neurais

A predição de (\alpha) foi refinada com redes neurais profundas para capturar padrões não lineares entre Cu+, VOCs e (\alpha). model = Sequential([ Dense(64, activation='relu', kernel_initializer='he_normal'), BatchNormalization(), Dropout(0.3), Dense(32, activation='relu'), Dense(1, activation='linear') ])

Função de perda: Erro absoluto médio (MAE) com regularização L2.

Hiperparâmetros ajustados: Número de camadas e taxa de dropout otimizados via GridSearchCV.

4.2. Comparação de Modelos

Os modelos foram avaliados com métricas estatísticas: Modelo MSE MAE (R^2) Random Forest 0.023 0.091 0.87 XGBoost 0.012 0.085 0.92 Redes Neurais 0.010 0.078 0.94

Os resultados mostram que redes neurais superaram modelos tradicionais, reduzindo o erro de predição de (\alpha).

5. Resultados e Discussão

5.1. Comportamento da Difusão de VOCs

Regimes de subdifusão ((\beta < 1)) foram observados para microambientes tumorais ricos em Cu+, resultando em uma dispersão mais localizada dos VOCs.

Efeito de Cu+: Amostras com maior concentração de Cu+ apresentaram maior amplitude de ( R_{\text{VOC}} ) e valores reduzidos de (\alpha), confirmando que o cobre regula a difusão dos VOCs.

5.2. Limitações e Trabalhos Futuros

O modelo assume homogeneidade espacial de ( [Cu^+] ), não capturando heterogeneidades tumorais.

A relação (\alpha = 2\beta) foi validada apenas para subdifusão pura; novas abordagens incluirão simulações estocásticas para validar esse comportamento.

6. Conclusão

Este estudo fornece um modelo quantitativo para a interação entre Cu+, ROS e VOCs no microambiente tumoral, validado experimentalmente via dados de GC-MS. Os achados sugerem que biomarcadores voláteis podem ser utilizados para estratificação de risco e diagnóstico não invasivo do câncer.

Perspectivas futuras incluem:

Integração com modelos metabólicos in silico (ex.: Recon3D) para prever VOCs específicos.

Validação experimental de (\alpha) em culturas 3D de tumores.

Anexos

Código Revisado: Solução da Equação Fracionária

import numpy as np from scipy.special import gamma def grunwald_letnikov(u, beta, dt, D): n = len(u) coeffs = [(-1)**k * gamma(beta + 1) / (gamma(k + 1) * gamma(beta - k + 1)) for k in range(n)] return D * np.convolve(u, coeffs, mode='same') * dt**(-beta)

Código para Geração de Dados

# Simulação de [ROS] e atividade de MMPs t = np.linspace(0, 10, 100) Cu = 0.5 # Concentração teórica de Cu+ ROS = [k_cu * Cu * np.exp(-gamma * ti) for ti in t] # Decaimento exponencial MMP_activity = [ROS_i**n / (K_m + ROS_i**n) for ROS_i in ROS]

Palavras-chave: Câncer, Cu+, ROS, Difusão Anômala, Aprendizado de Máquina, Modelagem Multiescala, Validação Experimental.

[ai-news]

A key component of deep convolutional neural network training is feature normalization, which aims to increase stability, reduce internal covariate shifts, and boost network performance. The development of several normalization approaches has result #AI #ML #Automation

[felord]

EE239AS Homework5-Implement convolutional neural network layers Solved

EE239AS Homework5-Implement convolutional neural network layers Solved

You should complete the notebooks in order, i.e., CNN-Layers, followed by CNN-BatchNorm, followed by CNN. This is due to potential dependencies. Note however, that CNN can be completed without CNN-Layers, since we provide the fast implementation of the CNN layers to be used in question 3. Implement convolutional neural network layers. Complete the CNNLayers.ipynb Jupyter notebook. Print out the…

[identikituniverse]

Gan hacks

This architecture involves seven best practices to consider when implementing your GAN model: 

1. Downsample Using Strided Convolutions (e.g. don’t use pooling layers). 

2. Upsample Using Strided Convolutions (e.g. use the transpose convolutional layer). 

3. Use LeakyReLU (e.g. don’t use the standard ReLU). 

4. Use BatchNormalization (e.g. standardize layer outputs after the activation). 

5. Use Gaussian Weight Initialization (e.g. a mean of 0.0 and stdev of 0.02). 

6. Use Adam Stochastic Gradient Descent (e.g. learning rate of 0.0002 and beta1 of 0.5). 

7. Scale Images to the Range [-1,1] (e.g. use Tanh in the output of the generator). 

These heuristics have been hard won by practitioners testing and evaluating hundreds or thousands of combinations of configuration operations on a range of problems.

[tensorflow4u]

RT @nsthorat: TensorFlow.js 0.10 released. tf.toPixels, batchnorm training and much more. Thanks to all our open source contributors. https://t.co/jENtPmRG20

[youjirec]

When using keras as a simplified interface to tensorflow, some Keras layers (stateful RNNs and BatchNormalization layers) have internal updates that need to be run as part of each training step. There are stored as a list of tensor tuples, layer.updates. We should generate assign ops for those, to be run at each training step. Here's an example:

[vladislav-karelin]

7 лет хайпа нейросетей в графиках и вдохновляющие перспективы Deep Learning 2020-х

Новый год все ближе, скоро закончатся 2010-е годы, подарившие миру нашумевший ренессанс нейросетей. Мне не давала покоя и лишала сна простая мысль: «Как можно ретроспективно прикинуть скорость развития нейросетей?» Ибо «Тот, кто знает прошлое — тот знает и будущее». Как быстро «взлетали» разные алгоритмы? Как вообще можно оценить скорость прогресса в этой области и прикинуть скорость прогресса в следующем десятилетии? 

Понятно, что можно примерно посчитать количество статей по разным областям. Метод не идеальный, нужно учитывать подобласти, но в целом можно пробовать. Дарю идею, по Google Scholar (BatchNorm) это вполне реально! Можно считать новые датасеты, можно новые курсы. Ваш же покорный слуга, перебрав несколько вариантов, остановился на Google Trends (BatchNorm).  Мы с коллегами взяли запросы основных технологий ML/DL, например, Batch Normalization, как на картинке выше, точкой добавили дату публикации статьи и получили вполне себе график взлета популярности темы. Но не у всех тем путь усыпан розами взлет такой явный и красивый, как у батчнорма. Некоторые термины, например регуляризацию или skip connections, вообще не получилось построить из-за зашумленности данных. Но в целом тренды собрать удалось. Кому интересно, что получилось — добро пожаловать под кат! Читать дальше → from Искусственный интеллект – AI, ANN и иные формы искусственного разума https://habr.com/ru/post/481844/?utm_campaign=481844&utm_source=habrahabr&utm_medium=rss via IFTTT

[eurekakinginc]

"[D] Batchnorm inference is a function of batch size / batch data"- Detail: Why is it that in tensorflow, the batchnorm results during inference time (e.g. using model.predict()) are dependent on the data in the batch? I would expect the network computation graph to be completely frozen.. Caption by idg101. Posted By: www.eurekaking.com