Usually, it&#39;s `glorot_uniform` by default. Different layer types might have different default `kernel_initializer`. When in doubt, just look in the source [code](https://github.com/fchollet/keras/blob/62d097c4ff6fa694a4dbc670e9c7eb9e2bc27c74/keras/layers/core.py#L798). For example, for `Dense` layer:

    class Dense(Layer):
    ...
        def __init__(self, units,
                     activation=None,
                     use_bias=True,
                     kernel_initializer=&#39;glorot_uniform&#39;,
                     bias_initializer=&#39;zeros&#39;,
                     kernel_regularizer=None,
                     bias_regularizer=None,
                     activity_regularizer=None,
                     kernel_constraint=None,
                     bias_constraint=None,
                     **kwargs):



**GlorotUniform**, keras uses Glorot initialization with a uniform distribution.r = √(3/fan_avg)

fan_avg = (fan_in + fan_out) /2

number of inputs = fan_in

number of nurons in a layer = fan_out

It is possible to set `.files` property of `&lt;input type=&quot;file&quot;&gt;` element to a `FileList` from for example a different `&lt;input type=&quot;file&quot;&gt;` element `.files` property or `DataTransfer.files` property. See [Make &lt;input type=file&gt;.files settable #2866][1], https://stackoverflow.com/questions/46636439/what-happens-between-uploading-a-file-to-an-html-form-and-submitting-it/.

`FileList` object has a `Symbol.iterator` property which we can use to set a `File` object which is iterable, however the `.files` `.length` is still set to `0` and passing a `&lt;form&gt;` having `&lt;input type=&quot;file&quot;&gt;` set where the `.files` is set using the above approach yields a `File` object having `.size` set to `0`.

How to set the `File` at `FileList` and set `.length` of `FileList` to the number of files set, where the files are set at `FormData()` object?

&lt;!-- begin snippet: js hide: false console: false babel: false --&gt;

&lt;!-- language: lang-js --&gt;

    const input = document.createElement(&quot;input&quot;);

    const form = document.createElement(&quot;form&quot;);

    const [...data] = [
      new File([&quot;a&quot;], &quot;a.txt&quot;)
    , new File([&quot;b&quot;], &quot;b.txt&quot;)
    ];

    input.type = &quot;file&quot;;

    input.name = &quot;files&quot;;

    input.multiple = true;
    // set `File` objects at `FileList`
    input.files[Symbol.iterator] = function*() {
       for (const file of data) {
         yield file
       };
    };

    form.appendChild(input);

    const fd = new FormData(form);

    for (const file of input.files) {
      console.log(file); // `File` objects set at `data`
    }

    for (const [key, prop] of fd) {
      // `&quot;files&quot;`, single `File` object having `lastModified` property
      // set to a time greater than last `File` object within `data`
      // at Chromium 61, only `&quot;files&quot;` at Firefox 57
      console.log(key, prop); 
    }

    console.log(input.files.length); // 0



&lt;!-- end snippet --&gt;


  [1]: https://github.com/whatwg/html/pull/2866

How to set File objects and length property at FileList object where the files are also reflected at FormData object?

I&#39;m new to ASP.NET Core and docker.
I&#39;ve created a simple ASP.NET Core 2.0 app and try to use docker with it on Windows. However, I get this error: 

`Your Docker server host is configured for &#39;Linux&#39;, however the docker-compose project targets &#39;Windows&#39;.`

Although it seems to be pretty informative error, I can&#39;t find where to &#39;configure host for Windows&#39;

ASP.NET Core docker build error

In the user manual, it shows the different kernel_initializer below

[https://keras.io/initializers/][1]

the main purpose is to initialize the weight matrix in the neural network.

Anyone knows what the default initializer is? the document didn&#39;t show the default.

  [1]: https://keras.io/initializers/

what is the default kernel_initializer in keras

In the user manual, it shows the different kernel_initializer below
<a href="https://keras.io/initializers/" target="_blank" rel="noopener noreferrer">https://keras.io/initializers/</a>
the main purpose is to initialize the weight matrix in the neural network.
Anyone knows what the default initializer is? the document didn't show the default.

Classification problems, such as logistic regression or multinomial
logistic regression, optimize a **cross-entropy** loss.
Normally, the cross-entropy layer follows the **softmax** layer,
which produces probability distribution.

In tensorflow, there are at least a **dozen of different cross-entropy loss functions**:

- `tf.losses.softmax_cross_entropy`
- `tf.losses.sparse_softmax_cross_entropy`
- `tf.losses.sigmoid_cross_entropy`
- `tf.contrib.losses.softmax_cross_entropy`
- `tf.contrib.losses.sigmoid_cross_entropy`
- `tf.nn.softmax_cross_entropy_with_logits`
- `tf.nn.sigmoid_cross_entropy_with_logits`
- ...

Which one works only for binary classification and which are suitable for multi-class problems? When should you use `sigmoid` instead of `softmax`? How are `sparse` functions different from others and why is it only `softmax`?

Related (more math-oriented) discussion: https://stackoverflow.com/q/44674847/712995. 


How to choose cross-entropy loss in TensorFlow?

What are the differences between `numpy.random.rand` and `numpy.random.randn`?

From the documentation, I know the only difference between them is the probabilistic distribution each number is drawn from, but the overall structure (dimension) and data type used (float) is the same. I have a hard time debugging a neural network because of this.

Specifically, I am trying to re-implement the Neural Network provided in the [Neural Network and Deep Learning book by Michael Nielson](http://neuralnetworksanddeeplearning.com/chap1.html). The original code can be found [here](https://github.com/mnielsen/neural-networks-and-deep-learning/blob/master/src/network.py). My implementation was the same as the original; however,  I instead defined and initialized weights and biases with `numpy.random.rand` in the `init` function, rather than the `numpy.random.randn`  function as shown in the original. 

However, my code that uses `random.rand` to initialize `weights and biases` does not work. The network won&#39;t learn and the weights and biases will not change.

What is the difference(s) between the two random functions that cause this weirdness?


Differences between numpy.random.rand vs numpy.random.randn in Python

I am trying to grasp what TimeDistributed wrapper does in Keras.

I get that TimeDistributed &quot;applies a layer to every temporal slice of an input.&quot;

But I did some experiment and got the results that I cannot understand.

In short, in connection to LSTM layer, TimeDistributed and just Dense layer bear same results.

    model = Sequential()
    model.add(LSTM(5, input_shape = (10, 20), return_sequences = True))
    model.add(TimeDistributed(Dense(1)))
    print(model.output_shape)

    model = Sequential()
    model.add(LSTM(5, input_shape = (10, 20), return_sequences = True))
    model.add((Dense(1)))
    print(model.output_shape)

For both models, I got output shape of **(None, 10, 1)**.

Can anyone explain the difference between TimeDistributed and Dense layer after an RNN layer?



What is the role of TimeDistributed layer in Keras?

Why does [`zero_grad()`](https://pytorch.org/docs/stable/generated/torch.optim.Optimizer.zero_grad.html) need to be called during training?

    |  zero_grad(self)
    |      Sets gradients of all model parameters to zero.


Why do we need to call zero_grad() in PyTorch?

It is not clear for  me the difference between loss function and metrics in Keras. The documentation was not helpful for me.

What is the difference between loss function and metric in Keras?

    import tensorflow as tf
    import tensorflow 
    
    from tensorflow import keras
    from keras.layers import Dense

I am getting the below error

    from keras.layers import Input, Dense
    Traceback (most recent call last):
    
      File &quot;&lt;ipython-input-6-b5da44e251a5&gt;&quot;, line 1, in &lt;module&gt;
        from keras.layers import Input, Dense
    
    ModuleNotFoundError: No module named &#39;keras&#39;

How do I solve this?

Note: I am using Tensorflow version 1.4


How to import keras from tf.keras in Tensorflow?

Im trying to save and load weights from the model i have trained.

the code im using to save the model is.

    TensorBoard(log_dir=&#39;/output&#39;)
    model.fit_generator(image_a_b_gen(batch_size), steps_per_epoch=1, epochs=1)
    model.save_weights(&#39;model.hdf5&#39;)
    model.save_weights(&#39;myModel.h5&#39;)

Let me know if this an incorrect way to do it,or if there is a better way to do it.

but when i try to load them,using this,

    from keras.models import load_model
    model = load_model(&#39;myModel.h5&#39;)

but i get this error:

---------------------------------------------------------------------------
    ValueError                                Traceback (most recent call 
    last)
    &lt;ipython-input-7-27d58dc8bb48&gt; in &lt;module&gt;()
          1 from keras.models import load_model
    ----&gt; 2 model = load_model(&#39;myModel.h5&#39;)

    /home/decentmakeover2/anaconda3/lib/python3.5/site-
    packages/keras/models.py in load_model(filepath, custom_objects, compile)
        235         model_config = f.attrs.get(&#39;model_config&#39;)
        236         if model_config is None:
    --&gt; 237             raise ValueError(&#39;No model found in config file.&#39;)
        238         model_config = json.loads(model_config.decode(&#39;utf-8&#39;))
        239         model = model_from_config(model_config, 
    custom_objects=custom_objects)

    ValueError: No model found in config file.

Any suggestions on what i may be doing wrong?
Thank you in advance.



Save and load weights in keras

I am a beginner in Keras and need help to understand `keras.argmax(a, axis=-1)` and `keras.max(a, axis=-1)`. What is the meaning of `axis=-1` when `a.shape = (19, 19, 5, 80)`? And also what will be the output of `keras.argmax(a, axis=-1)` and `keras.max(a, axis=-1)`?

What is the meaning of axis=-1 in keras.argmax?

I am trying out sample `keras` code from the below `keras` documentation page,
https://keras.io/applications/

What `preprocess_input(x)` function of `keras` module does in the below code? Why do we have to do `expand_dims(x, axis=0)` before that is passed to the `preprocess_input()` method?

    from keras.applications.resnet50 import ResNet50
    from keras.preprocessing import image
    from keras.applications.resnet50 import preprocess_input
    import numpy as np
    
    model = ResNet50(weights=&#39;imagenet&#39;)

    img_path = &#39;elephant.jpg&#39;
    img = image.load_img(img_path, target_size=(224, 224))
    x = image.img_to_array(img)
    x = np.expand_dims(x, axis=0)
    x = preprocess_input(x)

Is there any documentation with a good explanation of these functions?

Thanks!

Content Type	Original Author	Original Content on Stackoverflow
Question	Chris Chou	View Question on Stackoverflow
Solution 1 - Neural Network	Sergey Kovalev	View Answer on Stackoverflow
Solution 2 - Neural Network	RaaHul Dutta	View Answer on Stackoverflow

what is the default kernel_initializer in keras

Neural Network Problem Overview

Neural Network Solutions

Solution 1 - Neural Network

Solution 2 - Neural Network

ASP.NET Core docker build error

How to set File objects and length property at FileList object where the files are also reflected at FormData object?

Attributions