neuron | simplest possible event driven job manager , FIFO queue | Microservice library

I'm working with PyTorch tutorial, slightly modified to use Titanic dataset. I'm using very simple network of Linear(Dense) with ReLU... I'd like to predict survival status based on age, fare and sex for example.

I experienced a strange behavior with a simple neural network (I'm experimenting on Google Colab). Sometimes when I execute training, the accuracy doesn't change at all. It's strange because I'm recreating the model...

My network is not trained to recognize inputs separately, it either outputs the averaged result or becomes biased to one particular output. What am I doing wrong?

I am trying to add a neuron layer to my model which has tf.keras.activations.relu() with max_value = 1 as its activation function. When I try doing it like this:

I am testing something which includes building a FCNN network Dynamically. Idea is to build Number of layers and it's neurons based on a given list and the dummy code is:

I am doing a CNN online course assignment which builds a convolutional model. The instructions are listed as following:

Exercise 2 - convolutional_model

Implement the convolutional_model function below to build the following model: CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> DENSE. Use the functions above!

Also, plug in the following parameters for all the steps:

• Conv2D: Use 8 4 by 4 filters, stride 1, padding is "SAME"
• ReLU
• MaxPool2D: Use an 8 by 8 filter size and an 8 by 8 stride, padding is "SAME"
• Conv2D: Use 16 2 by 2 filters, stride 1, padding is "SAME"
• ReLU
• MaxPool2D: Use a 4 by 4 filter size and a 4 by 4 stride, padding is "SAME"
• Flatten the previous output.
• Fully-connected (Dense) layer: Apply a fully connected layer with 6 neurons and a softmax activation.

The code is here:

I'm testing a basic neural network model. But before go any further I've encountered this error shown in the screenshot.

Here is my code:

I am performing a NLP task where I analyze a document and classify it into one of six categories. However, I do this operation at three different time periods. So the final output is an array of three integers (sparse), where each integer is the category 0-5. So a label looks like this: [1, 4, 5].

I am using BERT and am trying to decide what type of head I should attach to it, as well as what type of loss function I should use. Would it make sense to use BERT's output of size 1024 and run it through a Dense layer with 18 neurons, then reshape into something of size (3,6)?

Finally, I assume I would use Sparse Categorical Cross-Entropy as my loss function?

I a newbie to python and learning neural networks. I have a trained 3 layer feed forward neural network with 2 neurons in the hidden layer and 3 in the output layer. I am wondering that how to calculate the output layer values/ predicted output

I have weights and biases extracted from the network and activation values calculated of the hidden layer. I just want to confirm that how can I use softmax function to calculate the out put of the output layer neurons?

My implementation is as follows:

I am attempting to reduce the dimensionality of a categorical feature by extracting an embedding layer from a neural net and using it as an input feature in a separate XGBoost model.

An embedding layer has the dimensions (nr. unique categories + 1, chosen output size). How can it be concatenated to the continuous variables in the original training data with the dimensions (nr. observations, nr. features)?

Below is a reproducible example of regression with a neural net, in which a categorical feature is encoded as a learned embedding layer. The example is closely adapted from: http://machinelearningmechanic.com/keras/2018/03/09/keras-regression-with-categorical-variable-embeddings-md.html#Define-the-input-layers

At the end I have printed the embedding layer and its shape. How can this layer be merged with the continuous features in the original training data (X_train_continuous)? If the number of rows were equal to the number of categories and if we knew the order in which categories are represented in the embedding layer, the embedding array could perhaps be joined to the training observations on category, but instead the number of rows equals the number of categories + 1 (in the code: len(values) + 1).