## Artificial intelligence – deep learning algorithms

I understand the concept, but I have only made assumptions about how I would create an algorithm that could compute bitmaps to define their content.

Have you ever seen an owl perched somewhere looking for prey? Notice how he can tilt his head and how he moves his head in a circular motion as he tries to make sense of what he sees? I guess this circular motion is made to change the angle of view to get a better idea in terms of depth perception. There is a reason why the owl has evolved to behave this way. Why not integrate such ideas into a machine learning algorithm.

If you are using bitmaps to perform machine learning, what are the benefits of rotating the bitmap and analyzing it? I ask because I really have no idea.

To get to the point, do you have experience using bitmaps for machine learning purposes? Have you ever had to apply Bayes' theorem in your work? (Https://en.wikipedia.org/wiki/Bayes&#39;_theorem)

I'm just scratching the surface here. I have not yet studied machine learning with bitmaps. It seems interesting and useful to me. Do any of you agree?

## distributed systems – What problem does the Yo-yo algorithm solve that deep research at first doesn't solve?

The Yo-yo algorithm has certain requirements, two of which catch my eye:

• Each node has a separate initial value (source)
• The algorithm is started by an initiator (source)

These conditions also allow you to perform an in-depth search first for the minimum ID, and the algorithm is simpler. So why use the Yo-yo algorithm?

## differential equations – Deep learning surpasses symbolic integration and ODE?

There is a new document on arXiv claiming that a deep learning model far surpasses Mathematica in symbolic integration and ODE resolution. The comparison of the success rate is as follows (waiting period of 30 seconds for the MMA evaluation).
The beam size means approximately the maximum authorized number of solutions found (not necessarily all correct). If one of them is correct, that is enough because verifying a solution is much simpler. This is what it means by a successful case.

The method is not complex. It starts by making mathematical expressions in the data structure of the binary tree, which naturally gives a sequence of prefix notation. Then they treat such a sequence of an integral or ODE as a sentence to be translated into another sequence (the solution), in the same way as in machine translation. They offer three ways to generate training sets, Forward (use MMA to integrate randomly generated elements), Backward (use MMA to differentiate randomly generated elements), Integration By Parts (use accumulated data to generate more).

I was wondering if it really went beyond MMA as they claimed. If so, that seems to be what you would expect in a next generation MMA. Or is it possible to achieve in the current version of MMA?

## ids – Scenario Categorization with Deep Packet Inspection – Intrusion Detection

I am researching intrusion detection systems (IDS) and deep packet inspections (DPI). Assuming a system in which the values ​​are transmitted to a validation system and the validation system validates (checks anomalies, for example by statistics, machine learning, etc.) the transmitted data.

• Is the validation process called DPI, even when only the payload is studied?
• Is the validation process called network-based intrusion detection or is it called something different?

## applications – Is there an operating system or software like Deep Freeze for Android?

Is there a live custom operating system for Android that is read-only and every time you restart your phone, every change is removed?

Or software like Deep Freeze for Windows?

If such solutions exist, can their security goal be circumvented? Can any one remotely disable the read-only feature and install malware?

## [ Politics ] Open question: Does anyone still believe that "The Deep State" does not exist in Washington DC?

[Politics] Open question: Does anyone still believe that "The Deep State" does not exist in Washington DC?

## python – Is there a way to make this code perform faster (deep learning)?

The purpose of this network is to see in the dark. I am a novice in deep learning and I have not had time to debug this network and test it. Although I would appreciate any advice.
Here is the code:

I used Tensorflow and sympy

class network():

def __init__(self, inputs, width, height, kernel_size=(5, 5)):
super(fully_convolution, self).__init__()
self.kernel_size = kernel_size
self.batch_size = 256
trial = 0

def elu(x, alpha=1):
return np.where(x < 0, alpha * (np.exp(x) - 1), alpha*x) #-1+ae^x{x<0}, ax{x>0}

def squeeze_net(input, squeeze_depth, expand_depth, scope):
# fire module used for keeping the same map size and reducing the number of parameters which keeps the neurons from being heavily affected
with tf.variable_scope(name, "squeeze", values=(inputs)):
squeezed = tf.nn.conv2d(input, squeeze_depth, (1, 1), name="squeeze")
x = tf.nn.conv2d(squeezed, expand_depth, (1, 1), name="1x1")
y = tf.nn.conv2d(squeezed, expand_depth, (3, 3), name="3x3")
return tf.concat((x, y), axis=0)

def count_sketch(img, x):
a, b = img.shape
c = np.zeros((a, x))
hash_indices = np.random.choice(x, b, replace=True) # memory table that convert one data to another
rand_sign = np.random.choice(2, b, replace=True) * 2 - 1 # generate random samples
matrix_a = img * rand_sign.reshape(1, b) # flip the signs of 50% columns of A
for i in range(x):
index = (hash_indices == i)
c(:, i) = np.sum(matrix_a(:, index), 1)
return c

def bilinear(x1, x2, output_size):
p1 = count_sketch(x1, output_size)
p2 = count_sketch(x2, output_size)
pc1 = tf.complex(p1, tf.zeros_like(p1))
pc2 = tf.complex(p2, tf.zeros_like(p2))

conved = tf.batch_ifft(tf.batch_fft(pc1) * tf.batch_fft(pc2))
return tf.real(conved)

def deconv_network(layer1, layer2, channel, pool_size=2):
filter = np.array((None, None), (None, None), dtype=np.int64)
layer = tf.nn.conv2d_transpose(layer1, filter, tf.shape(layer2), strides=(pool_size, pool_size))
bilinear = bilinear((layer, layer2), 3)
bilinear.set_shape((50, 50))
return bilinear

def bayes_prob(layer):
with tf.compact.v1.name_scope(“bayesian_prob”, values=(layer)):
model = tf.keras.Sequential((
tfp.layers.DenseFlipout(512, activation=tf.nn.relu),
tfp.layers.DenseFlipout(10),
))

logits = model(features)
neg_log_likelihood = tf.nn.softmax_cross_entropy_with_logits(
labels=labels, logits=logits)
kl = sum(model.losses)
loss = neg_log_likelihood + kl
return model

def refine_net(x1, x2, num_hidden):
n = int(num_hidden)
image = bilinear(x1, x2, 50)
x = tf.nn.conv2d(image, n*2, pool_size=2, padding=“valid”, activation_function=tf.nn.ReLU)
y = bayes_prob(x)

#______________________*light_enhancement*_________________________

image = tf.image.resize_nearest_neighbor(y, (50, 50))
dark = squeeze_net(image, n, n*2, scope=“dark”)
bright = tf.nn.conv2d(dark, n, 3, stride = (3, 3), activation=tf.nn.ReLU, padding='same')
bright2 = tf.nn.conv2d(n=n*2, 3, stride = (3, 3), activation=tf.nn.ReLU, padding='same')(bright)
bright3 = tf.nn.conv2d(n=n*2, 3, stride = (3, 3), activation=tf.nn.ReLU, padding='same')(bright2)

conv_resize = tf.image.resize_nearest_neighbor(bright3, (50, 50))

layer1 = tf.nn.conv2d(n*2, 3, stride(1, 1), activation=tf.nn.ReLU, padding='same')(conv_resize)
layer2 = deconv_network(layer1, bright3, n*2)
layer3 = tf.nn.conv2d(n*2, 3, stride(1, 1), activation=tf.nn.ReLU, padding='same')(conv_resize)
layer4 = deconv_network(layer3, bright2, n*2)

output_size = tf.image.resize_nearest_neighbor(layer4, (tf.shape(y)(1), tf.shape(y)(2)))

light_image = bilinear(output_size, y, 50)
enhancement = Model(input=dark, output=light_image)

n = int(num_hidden)

#_____________________*deblurring*________________________

blur_net = squeeze_net(y, n, n*2, scope="blur")
deblur_net = tf.nn.conv2d(blur_pixel_net, n, strides, pool_size=2, padding="same", tf.nn.ReLU)
deblur_squeeze = tf.squeeze(deblur_net, (10, 10), scope="depixel")
deblur_layer = deconv_network(deblur_squeeze, deblur_net, n=n*2, pool_size=3)
deblur_layer2 = deconv_network(deblur_layer, deblur_net, n*2, pool_size=3)

deblur_output = deconv_network(deblur_layer2, deblur_net, n*2, pool_size=3)

deblur = Model(input=blur_net, output=deblur_output)

n = int(number_hidden)

#_______________________*denoising*________________________

# Encoder: Uses activation techniques; Sigmoid for accuracy

bias = tf.Variable(tf.random_normal(n))

# Decoder

if trial == 0:
weights = tf.Variable(tf.math.abs(tf.random_normal(n, n_=2*n)))
weights = tf.Variable(tf.math.abs(tf.random_normal(n_, n)))

autoencoder = Model(input=encode, output=decode)

#----------------------------------------------------------

#uses parameter sharing and breaks down into certain tasks
dropout = layers.Dropout(rate=0.12, noise_shape=(batch_size, 1, features), seed=None)
merge = bilinear(deblur, decoder, n)
merge = bilinear(merge, enhancement, n)
deconv_output = deconv_network(merge, y, n*2, n*4, pool_size=5)
upsampling_output =  tf.nn.upsampling2d(pool_size=(3, 3), interpolation='bilinear')(deconv_output)

global_step = tf.Variable(0, trainable = False)

loss_light = enhancement.compile(loss='sparse_categorical_crossentropy',
loss_deblur = deblur.compile(loss='sparse_categorical_crossentropy',
input = tf.placeholder(tf.float32, (None, None, None, 3), name='input')
loss_noise = tf.reduce_mean(tf.pow(input - decode, 2))

lr = tf.train.exponential_decay(1e-3, global_step, 100, 0.96)
train_op_light = optimizer_light.minimize(loss_light, global_step=global_step)

train_op_deblur = optimizer_deblur.minimize(loss_deblur, global_step=global_step)

train_op_noise = optimizer_noise.minimize(loss_noise, global_step=global_step)

return upsampling_output

#Makes Completely Dark Image Contain Less Noise & Black Level:Encode Check For Filter/ Neuron Size
def model(input=self.input):

Conv1 = tf.nn.conv2d(input, 16, 2, strides=(1,1), padding='same', activation=elu)
Conv1_ = tf.nn.conv2d(Conv1, 16, 2, strides=(1,1), padding='same', activation=elu)
Pool1 = MaxPooling2D(pool_size = kernel_size)(Conv1_)
Conv2 = tf.nn.conv2d(Pool1, 32, 3, strides=(1,1), padding='same', activation=elu)
Conv2_ = tf.nn.conv2d(Conv2, 32, 3, strides=(1,1), padding='same', activation=elu )
Pool2 = MaxPooling2D(pool_size = kernel_size)(Conv2_)
Conv3 = tf.nn.conv2d(Pool2, 96, 3, strides=(1,1), padding='same', activation=elu)
Conv3_ = tf.nn.conv2d(Conv3, 96, 3, strides=(1,1), padding='same', activation=elu )
Pool3 = MaxPooling2D(pool_size = kernel_size)(Conv3_)
Refine = refine_net(Pool2, Pool3, 8)
Conv4 = tf.nn.conv2d(Refine, 128, 3, strides=(1,1), padding='same', activation=elu)
Conv4_ = tf.nn.conv2d(Conv4, 128, 3, strides=(1,1), padding='same', activation=elu )
Pool4 = MaxPooling2D(pool_size = kernel_size)(Conv4_)
Refine2 = refine_net(Pool3, Pool4, 16)
Conv5 = tf.nn.conv2d(Refine2, 256, 3, strides=(1,1), padding='same', activation=elu)
Conv5_ = tf.nn.conv2d(Conv5, 256, 3, strides=(1,1), padding='same', activation=elu)
Pool5 = MaxPooling2D(pool_size=kernel_size)(Conv5_)
output = refine_net(Pool4, Pool5, 32)

return output

## [ Politics ] Open question: Do the 14 witnesses to Trump's dismissal lie and be part of the deep state?

[Politics] Open Question: Are the 14 witnesses to Trump's dismissal all liars and part of the deep state?

## integers – Quantification in deep neural networks

I am this tutorial on the quantification in tensorflow.

tutorial 1
tutorial 2

Tutorial 1 describes the quantization formula as follows:

My question is, if you have 3 floating point values -10, 10, 30how to calculate quantization values ​​practically.

In Tutorial 2, how does the floating point value -10 match the quantized value 0?

## Windows of Applications – Faronics Deep Freeze Enterprise 8.60.220.5582 | NulledTeam UnderGround

Size of the file: 56.5 MB

Faronics Deep Freeze helps eliminate damage and downtime from the computer by making computer configurations indestructible. Once Deep Freeze is installed on a computer, changes to the computer, whether accidental or malicious, are never permanent. Deep Freeze offers immediate immunity to many of the problems that affect computers today. Inadvertent drift in configuration, accidental misconfiguration of the system, malware activity, and accidental system degradation.
A flawless stay

Whatever changes a user makes to a workstation. Simply restart the computer to remove all changes and reset the computer to its original state, until the last byte. Costly computing resources continue to operate at 100% capacity and technical support time is reduced or eliminated completely.
The result is consistent, trouble-free computing on a truly protected and parallel network, totally free of viruses and unwanted programs.

Supported Operating System: Windows XP, Vista, Windows 7, 8, 8.1, 10 and Server 2003, 2008, 2012, 2016 (32-bit, 64-bit).

What's up