Python-Machine-Learning | Python Machine Learning Algorithms | Machine Learning library

Use groupby with a unique list. groupby does exactly what you are asking for as in, it iterates over each group and each group is a dataframe. So, if you manipulate it such that you groupby a value that is unique for each and every row, you'll get a single row dataframe when you iterate over the group

You defined the class Perzeptron but create an instance of Perceptron (c instead of z). It seems like you defined Perceptron earlier in your ipython session without defining the __init__ method taking two arguments.

You can think of the density graph that it shows the relative number of occurrences of the data at given values. The values in question are differences between observed and fitted variable values. If the fit was perfect, all the differences would have been 0, and there would have been just one bar at 0. The fit is not perfect, and there are some differences greater or smaller than 0, but they are not too far from zero.

The conclusion authors draw is probably too strong: the graph does not prove the differences are close to zero, but it suggests the differences are centered around zero. Generally, it is a good result for linear regression.

Setting the estimated attributes alone is not enough - at least in the general case for all estimators.

I know of at least one example where this would fail. LinearDiscriminantAnalysis.transform() makes use of the private attribute _max_components:

By documenation this should be axis...but that can't be, right?

From tensorflow 1.0 onwards, the first argument of tf.split is not the axis, but I assume that the code was written using an older version where the first argument is indeed the axis.

Isn't x one dimensional?

x is not one dimensional. Right before the call to tf.split, x is reshaped from 3 to 2 dimensions with this statement:

Here is solution: https://www.reddit.com/r/learnpython/comments/6qc9t1/path_to_existing_file_in_root_folder_not_found_on/

It was typo hahah. Sorry to all, I just haven't noticed.

This is loaded question. Let me try to put it in simple English hiding all the complicated inner details:

A simple Unrolled LSTM model with 3 steps is shown below. Each LSTM cell takes an input vector and the hidden output vector of the previous LSTM cell and produces an output vector and the hidden output for the next LSTM cell.

A concise representation of the same model is shown below.

LSTM models are sequence to sequence models, i.e, they are used for problems when a sequence has to be labeled with an another sequence, like POS tagging or NER tagging of each word in a sentence.

You seem to be using it for classification problem. There are two possible ways to use LSTM model for classification

1) Take the output of all the states (O1, O2 and O3 in our example) and apply a softmax layer with softmax layer output size being equal to number of classes (2 in your case)

2) Take the output of the last state (O3) and apply a softmax layer to it. (This is what you are doing in your cod. outputs[-1] return the last row in the outputs)

So we back propagate (Backpropagation Through Time - BTT) on the error of the softmax output.

Coming to the implementation using Tensorflow, lets see what is the input and output to the LSTM model.

Each LSTM takes an input, but we have 3 such LSTM cells, So the input (X placeholder) should be of size (inputsize * time steps). But we don't calculate error for single input and BTT for it, but instead we do it on a batch of input - output combinations. So the Input of LSTM will be (batchsize * inputsize * time steps).

A LSTM cells is defined with the size of hidden state. The size of output and the hidden output vector of the LSTM cell will be same as the size of the hidden states (Check LSTM internal calcuations for why!). We then define an LSTM Model using a list of these LSTM cells where the size of the list will be equal to the number of unrolling of the model. So we define the number of unrolling to be done and the size of input during each unrolling.

I have skipped lots of things like how to handle variable length sequence, sequence to sequence error calcuations, How LSTM calcuates output and hidden output etc.

Coming to your implementation, you are applying a relu layer before the input of each LSTM cell. I dont understand why you are doing that but I guess you are doing it to map your input size to that of the LSTM input size.

Coming to your questions:

1. x is the placeholder (tensor/matrix/ndarray) of size [None, input_vec_size, 1]. i.e it can take variable number of rows but each row with input_vec_size columns and each element being a vector is size 1. Normally placeholders are defined with "None" in the rows so that we can vary the batch size of the input.

lets say input_vec_size = 3

You are passing a ndarray of size [128 * 3 * 1]

x = tf.transpose(x, [1,0,2]) --> [3*128*1]

x = tf.reshape(x, [-1, 1]) --> [384*1]

h_layer['weights'] --> [1, 128]

x= tf.nn.relu(tf.matmul(x, h_layer['weights']) + h_layer['biases']) --> [384 * 128]

1. No input size are hidden size are different. LSTM does a set of operations on the input and previous hidden output and given an output and next hidden output both of which are of size hidden size.

2. x = tf.placeholder('float', [None, input_vec_size, 1])

It defines a tensor or ndarray or variable number of rows, each rows has input_vec_size columns an and each value is a single value vector.

x = tf.reshape(x, [-1, 1]) --> reshapes the input x into a matrix of size fixed to 1 column and any number of rows.

1. batch_x = batch_x.reshape(batch_size ,input_vec_size, 1)

batch_x.reshape will fail if number of values in batch_x != batch_size*input_vec_size*1. This might be the case for last batch because len(train_x) might not be a multiple of batch_size resulting in the non fully filled last batch.

You can avoid this problem by using

fit(x,y) is a method that can be used on an estimator.

In order to be able to use this method on model you would have to create model first and make sure its of an estimator class.

Documentation