DEV Community: Karan

Fashion MNIST with not so deep learning

Karan — Thu, 03 Jan 2019 14:52:20 +0000

Hi Devz!

This is a post on using the 'knowledge' gained from part 1 of the Deep Learning with Python book to classify FASHION MNIST images which is dataset of 60,000 images.

This is really an extension of the MNIST Digit Recognizer for identification of different kind of wearables, coat, shirt, shoes etc.

As you can see from the heading, I didn't use the deeper part of DL, which is convolutional neural networks and to be frank just brute forced several combinations until I got the best accuracy on test data.

I used a combination of the following and took the one which had the highest test accuracy:

Multiple hidden layers
Multiple unit combination in those hidden layers
Multiple combination of units in the first layer

The best model was having 1 hidden layer with 128 units and 512 units in the outer layer and an accuracy of 89.04%.

this is not how it should be done though, since resources are limited in real world for working on real, hard ML problems!😞

Code

from keras import models
from keras import layers
from keras.datasets import fashion_mnist
import numpy as np
import matplotlib.pyplot as plt
from keras.utils import to_categorical, plot_model
import operator

(train_x, train_y), (test_x, test_y) = fashion_mnist.load_data()

def shape(arr):
    x = np.reshape(arr, (len(arr), 784))
    return x

#epochs
e = 40

#prediction array
eval_arr = {}
pred_arr = {}


#label summary
label_list = {0: 'T-shirt/top', 1: 'Trouser', 2:'Pullover', 3:'Dress', 4:'Coat', 5:'Sandal', 6:'Shirt', 7:'Sneaker', 8:'Bag', 9:'Ankle boot'}

#path
output_dir_model = r'C:\Users\karan.verma\.spyder-py3\deep-learning\models'

train_x_reshaped = shape(train_x).astype('float32')/255
train_y = to_categorical(train_y)
train_y = train_y.astype('float32')

test_x_reshaped = shape(test_x).astype('float32')/255
test_y = to_categorical(test_y)
test_y = test_y.astype('float32')

#take out validation data, 25% = 15,000 samples

partial_train_x = train_x_reshaped[:int(len(train_x_reshaped)*0.75)]
partial_train_y = train_y[:int(len(train_y)*0.75)]

val_x = train_x_reshaped[int(len(train_x_reshaped)*0.75):]
val_y = train_y[int(len(train_y)*0.75):]

# run model with several different parameters

#lyrs = [1, 2]
#units_out = [512, 256, 128, 64, 32, 16]
#units_in = [128, 64, 32, 16]

lyrs = [1]
units_out = [512]
units_in = [128]

#make model
for lyr in lyrs:
    for unit_out in units_out:
        for unit_in in units_in:

            print('Running model having %d hidden layers & %d units in each hidden layer and %d units in the outer layer' % (lyr, unit_in, unit_out))

            model = models.Sequential()
            model.add(layers.Dense(unit_out, activation='relu', input_shape=(784,)))

            for i in range(lyr):
                model.add(layers.Dense(unit_in, activation='relu'))

            model.add(layers.Dense(10, activation = 'sigmoid'))

            #compile model
            model.compile(optimizer = 'rmsprop',
                          loss = 'categorical_crossentropy',
                          metrics=['accuracy'])

            #model fit

            history = model.fit(partial_train_x,
                                partial_train_y,
                                epochs = e,
                                batch_size=512,
                                validation_data=(val_x, val_y),
                                verbose = 1)

            acc_list = history.history
            fig, ax = plt.subplots(2,1, figsize=(20, 10))

            plt.subplot(211)
            plt.plot(np.arange(1, e+1), acc_list['loss'], label='Training Loss')
            plt.plot(np.arange(1, e+1), acc_list['val_loss'], label='Validation Loss')
            plt.title('Loss Graph')
            plt.xlabel('Epochs')
            plt.ylabel('Loss')
            plt.legend()

            plt.subplot(212)
            plt.plot(np.arange(1, e+1), acc_list['acc'], label='Training Acc')
            plt.plot(np.arange(1, e+1), acc_list['val_acc'], label='Validation Acc')
            plt.title('Accuracy Graph')
            plt.xlabel('Epochs')
            plt.ylabel('Accuracy')
            plt.legend()

            #plt.tight_layout()
            fig.savefig('{}/Model having %d hidden layers & %d units in each hidden layer and %d units in the outer layer.png'.format(output_dir_model) % (lyr, unit_in, unit_out))            
            plt.clf()

            eval_arr['Model having %d hidden layers & %d units in each hidden layer and %d units in the outer layer' % (lyr, unit_in, unit_out)] = model.evaluate(test_x_reshaped, test_y)
            pred_arr['Model having %d hidden layers & %d units in each hidden layer and %d units in the outer layer' % (lyr, unit_in, unit_out)]= np.argmax(model.predict(test_x_reshaped), axis=1)

#get best model from eval_arr
best_model = {}
k = ''

for key, val in eval_arr.items():
    best_model[key] = val[1]

print('The best model is: {}'.format(max(best_model.items(), key=operator.itemgetter(1))))

#Building Prediction Pipeline
#('Model having 1 hidden layers & 128 units in each hidden layer and 512 units in the outer layer',0.8953) but it varies

prediction = model.predict(test_x_reshaped)

print('Random samples from the test data: ')
fig, ax = plt.subplots(2, 3, figsize=(20, 10))
for i in range(1, 7):
        c = np.random.choice(len(test_x_reshaped))
        plt.subplot(2,3,i)
        plt.imshow(test_x[c])
        plt.title('Original {} & Predicted {}'.format(label_list[np.argmax(test_y[c])], label_list[np.argmax(prediction[c])]))

Output Graph

Key Takeaways

If you're working on an ML problem, spend time understanding the graphs, otherwise it won't make any sense
Try problems outside of the book/tutorial etc.
Implement stuff on your own without any guidance, it will make your brain hurt, but you'll learn.
Get stuck multiple times, google it, make it work and move forward to section 2 of the book! 😂

Link to code.

**Edit: Always forget, but all questions, comments, critique are wholeheartedly welcome! 😃

Enjoy your day!

Single Label Multiclass Classification Using Keras

Karan — Wed, 19 Dec 2018 08:23:22 +0000

Hi DEVz,

It's my second post using Keras for machine learning. This time it's the next lesson in the book for Multiclass Classification. This post is pretty much like the last post, the only difference is that I've tried to put some explanation in the following diagram which I hope will make you/or me in future understand why was the data split and what is one hot encoding.😊

What's multiclass classification?

Multiclass classification or more specifically in this case single label multiclass classification would allow you to put a sample in one category out of many, i.e. it's an extension of binary classification.

For Example: A movie can be good or bad, which is binary, however it's genre could be single label out of several genres, for example it could be: Horror out of [Thriller, Romance, Drama, Action, Adventure]

What's one hot encoding?

The diagram shows you how you represent a single label as an array whose length is the number of labels, and that my fellow devs is one hot encoding.
Each sample can lie in only ONE of the 46 categories of labels or topics to be precise.

46 Labels? How would that affect the neural networks?

Good question! This time instead of using 16 units in a hidden layer, we'll use 64 units. Why? you ask...because last time we only had 2 labels (postive or negative sentiment) however this time we have 46 topics and to NOT DROP any of that information from the 46 size array we need an even larger input stack and so we use a 64 unit layer for input and a 46 unit layer for output.

This exercise is based on classifying Reuters news feeds into labels, and for some reason I can't find the text of the label!😅

The source is here.
Enjoy!

Keras Sentiment Analysis in plain english

Karan — Wed, 12 Dec 2018 13:28:02 +0000

Hi devzzz!

I'm trying to learn ML and recently bought the book Deep Learning with Python by François Chollet.

Here's an implementation of the IMDB sentiment model from the book with some changes, I'll try and explain what I know and what I did, apologies for my code 😓.

Premise

Machine learning essentially uses math equations which can be tweaked to do shallow things that humans can do very easily.
Deep learning is machine learning with neural networks, like layers of meshes lying one on top of another. Each network is again, a math equation, multiple layers of neural networks are well multiple math equations on top of another.
Each networks has weights associated with it, like a coefficient in an equation. Like when you say y = ax + b, then a is the weight associated with x. Don't worry about it too much as Andrew Ng says.😊
When you put these network adjacent to each other and train them using data they form what everyone in the ML field call as an internal representation.
These internal representations is what the networks see based on the world of data which they have been trained on. Think of yourself as a caterpillar who's crawling along the floor and all your life, all you know is that there is something beneath you on which you crawl, even though you've never seen it, even though you don't know that it is and you obviously don't care about the humans who built it but you know mentally that If I crawl on this I'll be able to move.
In the same way this model is trying to learn if sentiments are positive or negative. Remember it cannot actually feel or understand the sentiments but with the help of labelled data this is possible.
Labelling is the cornerstone of supervised learning (part of machine learning where models learn by showing examples of something). It's like showing a kid what a car is then they're able to identify cars like experts, machine learning models though are obviously way behind in that general sense.

Code

What's Keras btw? : As far as I understand from the book and online articles, it's an API specification which calls lower level functions of other ML libraries such as Tensorflow, CNTK or Theano. To say simply, it makes it a lot easier for anyone to use lower level libraries without getting bogged down by the details. At a given point of time it can use any one of those and you won't have to change anything in your code on the top! A super naive view would be Keras is your front end and Tensorflow/CNTK/Theano are your backends :)

import stuff

import numpy as np # for numerical arrays
from keras import models #book told me to do it ! :) 
from keras import layers
from keras.datasets import imdb
from keras import optimizers
import matplotlib.pyplot as plt # for plotting

get the data

Keras allows you to directly import data into your program without hassle.

(train_data, train_labels),(test_data, test_labels) = imdb.load_data(num_words = 10000)

And it's so sweet that it splits the data into training and testing.

training and testing data?

Well you might have heard people throwing words around like overfitting, underfitting to sound cool? Well this is what they're talking about. When you get a bunch of rows, thousand of rows (yes think of it as excel rows and columns) of data, the best idea is to divide it into training and testing. The training data trains the models (neural network layers) and the testing data is used to see if the model actually is any good. You'll see more on this later.

labels?

Let's see a simple table below:

User	Age	Can Code?
Geoffrey	21	No
Yann	22	Yes
Andrew	23	Yes
Me	31	No
Mom	52	No
Dad	54	No
Bro	27	Yes

So here the labels are the last column, Can Code?, more importantly when you ask the model to look at these, you need to make them binary, i.e. No for 0 and 1 for Yes.

Let's split this data:

Training Data: train_data would be columns User & Age, train_labels would be Can Code?

User	Age	Can Code?
Geoffrey	21	No
Yann	22	Yes
Andrew	23	Yes

Testing Data: test_data would be columns User & Age, test_labels would be Can Code?

User	Age	Can Code?
Me	31	No
Mom	52	No
Dad	54	No
Bro	27	Yes

In our case of IMDB comment sentiment analysis, the data is like this:

Comments	Label
Row1 of word indices	1
...
Row N-1 of word indices	0
Row 50,000 of word indices	1

Word indices is an array which holds the frequency number of a word which appears in a comment.

Say for example: "Shawshank Redemption is probably the best movie ever", this would be translated to the following based on the frequency of the words in the english corpus as follows:

?	?	6	239	1	115	17	123	1

The last value of 1 is actually saying this is a positive comment, by a human who has labelled it, in this case it's your truly :). You can try this yourself if you have keras installed as follows:

from keras.datasets import imdb
s = "Shawshank Redemption is probably the best movie ever"
for word in s.split(' '):
    print(word_index.get(word, '?'))

not all comments are of the same length dude! & vectorize

Yes, you're right and so we use something called one hot encoding to convert this mess of words into a standard length of an array of 10,000 elements, remember this?:

num_words = 10000

This limits the comments to have only those words which have a frequency of more than 10,000, i.e. they are used most often.

x_train = np.zeros([len(train_data),10000])
for number, sequence in enumerate(train_data):
    x_train[number, sequence] = 1

And you do this with the test data as well, since you'd need to maintain consistency when you test the model which works on arrays of 10,000 elements right?

so...

#in the book it is done as a function...but like right now.....ignore it
x_test = np.zeros([len(test_data),10000])
for number, sequence in enumerate(test_data):
    x_test[number, sequence] = 1

Vectorize (or make them into numpy arrays) the labels as well:

#vectorize labels
y_train = np.asarray(train_labels).astype('float32')
y_test = np.asarray(test_labels).astype('float32')

what is validation?

Now comes a part where we split the training data as well! Yeah, but why do that?

What's over or underfit?

If a model is overfit, it means it's sticking so close to the data it trained on, that it cannot identify/classify/work on anything outside of what it encountered during training, just like saying "I now know what a Honda Civic is" but then when you see any different car you just say "that's Honda Civic! And that's Honda Civic and that's Honda Civic!"

On the other hand, when in an underfit scenario, it's going to be "I now know what a Honda Civic is" but then whenever you see a new car you say "well what is that? It's not a Honda Civic! Is it even a car? What is it?".

And so let's do some simple math here:

Keras IMDB data gives us 50,000 rows or samples.

25,000 went to training --> 15,000 would go into actually training those neural networks and the rest 10,000 would go into validation. Validation essentially refers to using training derived data to tune the model, to make it WORK, whenever we make some changes and train the model again on those 15,000 samples we check the result on the validation set of 10,000 samples.

Remember we never touched the rest of the 25,000 which are into the test set, not touching it at all! And that's the whole point of machine learning: how to use data generously to train a model to generalize while at the same time preventing overfitting and underfitting, therefore the test data will never have any contribution towards training the model.

where is the machine learning in all this?

Here we are, we will define the model and inputs that go into it.
I have added some for loops into the model creation area of the program to test different types of activation functions, loss functions, hidden layers and hidden units.

Let me show you:

#model iterations
activations = ['relu', 'tanh']

loss_func = ['mse', 'binary_crossentropy']

hidden_layer_units = [16, 32, 64]

hidden_layers = [1,2,3]

for activation in activations:
    for function in loss_func:
        for units in hidden_layer_units:
            for lyrs in hidden_layers:

What's an activation function?

Relu or tanh/sigmoid which are rectified linear units and hyperbolic functions which put some non linear(non linear is fancy way of saying not on a straight line) vibe into the math equations we're using. These are nothing but operations on the neural network mesh to make those internal representations and primarily in the end learn a good representation of the input data. Again don't worry about it too much, I just went ahead and used them!

What's a loss function?

Imagine your guitar tutor telling you that the riff you just played was not even close to how Slash plays it! You're furious, it sounds pretty good to you, but not to the tutor! So how do you tell if you're improving? Well one way is to record yourself playing and listening to it and then using that feedback to improve so you could reduce the difference between you and Slash. That's what a loss function is calculating. It's trying to minimize the difference between what it predicts and what the actual label is.

In this case, it would be:

Human
Comment : "Shawshank redemption is the bomb yo!" Label : 1

Model
Comment : "Shawshank redemption is the bomb yo!" Prediction : 0.85

As you see this model has probably been trained well and it's prediction is about 0.85 or 85%, that is leaning to 1.

hidden layers and hidden units?

These items are to be covered in the book in more depth! 😂 But they form the deep part of deep learning. Say you have 3 layers:

Layer 1 : Input layer which accepts that 10,000 element array
Layer 2 : A middle (hidden)layer with an activation function, takes input from layer 1 of 10,000 elements and spits out 16 element output.
Layer 3 : An output layer with an activation function, takes input from layer 2 of 16 elements and spits out a 1 element output.

In the above case we have 1 hidden layer with 16 units.

The only reason I added those for loop was to try all the activations, loss functions etc. Loop over all of them to find the best fit as you see below.

GO GO GO GO!

We define the model, if you see the three layers above, the following lines are doing just that. The for loop in between just adds layers on different iterations which may return a better prediction.

#print(activation, function, units, lyrs);
#write model
model = models.Sequential()
model.add(layers.Dense(16, activation = 'relu', input_shape = (10000,)))

for i in range(0,lyrs):
    model.add(layers.Dense(units, activation = activation))    

model.add(layers.Dense(1, activation = 'sigmoid'))

#optimzers, loss etc.
model.compile(optimizer = optimizers.RMSprop(lr = 0.001),
                              loss = function,
                              metrics = ['accuracy'])

The last line is adding another beast, the optimizer, which if you take the guitar example is like saying how will you reduce the difference between yourself and Slash, by:

Practicing 24 hours a day?
Or, selling your soul to the devil?
Or, asking Slash to play in your place?

To put in plain english the optimizer works on the loss function to reduce the error rate of the model and hence increase the accuracy.

history = model.fit(x_train_partial,
                    y_train_partial,
                    epochs = 10,
                    batch_size = 512,
                    validation_data=(validation_x_train, validation_y_train))

This line above is where you see the magic happen on the terminal! THE ACTUAL TRAINING, try it out, it's oddly satisfying! 😌

Where do we go from here?

Well the model training part is half the stuff done, the part is looking at the results, the accuracy, whether the model overfits or underfits etc and then changing your parameters. Any of the following:

Learning rate
Activation function
Epochs - how many passes you make over the training data
Hidden layers
Hidden units
Loss function

And that's where this article ends, I still haven't found the right combination, although I think it's a simpler problem, considering it's the first in the book!

Here is one of the outputs from the model, one of the 36 combinations:

Here is the code:

hydroweaver's GIT

You might have to change the paths to save the images and the models.

go run yourself a model :) and sorry for the long post!

One of many lessons on learning from companies regarding shiny new stuff.

Karan — Mon, 26 Nov 2018 07:33:59 +0000

I have spend many years learning (and not achieving anything) new things which had absolutely no relevance to what my job requires, or the things I actually needed/wanted to learn, say ML etc. This is primarily aimed at newbies like myself who are self-starters and have a specific goal in mind, but are led astray by the focussing on things which don't add absolute value. This is also meant to be a post to myself when I make this mistake in future! 😅

So I'll just add some opinions on the brilliant posts by

[Deleted User]

Ben HalpernFollow

A Canadian software developer who thinks he’s funny.

for

Article No Longer Available

Write clean code and avoid the distractions of emerging technology

Ben Halpern ・ Jan 14 '18

#beginners #career #productivity

respectively.

Here goes:

Unless you have, as a person, infinite time and money to spare, time more specifically to dive into new things don't do it.
Jumping into new stuff is tantamount to a large organization trying new stuff, so that MAYBE in future they might be able to get some use out of it and eventually specifically: COST SAVINGS AND/OR INCREASED REVENUE. And I'm not talking about tech product companies here :).
A bank(say) uses technology to make ends meet, not the other way around, we can say everything is technology now, but that's not the point. Any new technology is tried on the merit of bringing hard benefits.
Trying new stuff and investing time in it DOES NOT shift the focus from core competency, so should be the case for the individuals.
Your goal as an individual is different from a company, companies exist for PROFIT whereas individuals exist for some undefined abstract goal and experiencing net positive emotions.

So, focus on the one thing, and try not to invoke LET'S TRY THIS when a new article appears on the evergreen news feed :).

See you!

explainable web?

Karan — Fri, 02 Nov 2018 02:22:10 +0000

Hi everyone!

I just wanted to put this out, if there anything which resembles XAI for web. I don't know if this is even a valid point.

There are many tools, platforms, analysers which might be niche for a particular part of web, say traffic analysis or user behaviour etc., but what about looking at the whole picture? There is DOM and all the other things, inspecting stuff in browsers, but is that something an end user would be able to understand and care about?

On the other hand, the whole debate about black box models in machine/deep learning and biases and so forth has been a discussion front page in ML in 2018! Did we just skip the entire web and jump onto something which was more esoteric, because people think PhDs are working on it? I mean obviously the web is a trillion times more complex than a model predicting something, it's the arrogance of thinking that web is a solved problem.

Is that what Tim Berners-Lee is doing with SOLID & Inrupt? Because I don't understand blockchain really ! :(

And so, in my limited knowledge, I wanted to ask if there are tools which allows you to basically look though the web(what's my UI doing, what happens if I click this, what's the point of this, how was this comment added, what will happen if I click on this like) just like say tensorplayground allows you to look through a model, even though you might need some background knowledge.

Also, I apologise for my extremely limited knowledge of the web, please forgive me!😅

Re-assign or filter?

Karan — Wed, 31 Oct 2018 12:02:29 +0000

Hi Everyone!

A simple post here, taking a look at the comparison between what I did and what was the best solution for CodeWars Array.diff 6 Kyu problem.

Problem

Given two arrays a and b, remove items all b items from a and return, in case they don't match return a.

What I did?

Go through each item in b using a forEach loop.
If you find the item in a remove it and reassign a using filter function.
Goto point 1 and get next item from b.
When no more items left in b, return the new a.

function array_diff_ME(a, b) {
  b.forEach(function(item, index){
      a = a.filter(x=>x===item?false:true);
  });
  return a;
}

array_diff([1,2,3,4], [4,1,3]);

So what's the problem?

It uses an extra forEach loop which is not needed, and problem can be solved just by using a single filter function.

The Better Solution

As it turns out, a single filter function on a can do the trick. It works as follows:

Go through each item in a and check if the item exists in b using the indexOf function.
If indexOf(item) is -1, then filter function returns a true and that value is kept in a through filter, however if indexOf(item) is not -1 then filter function returns a false and item is filtered OUT of a.
Return the new a.

Here's the 'pseudo'-pseudocode!

function array_diff_PEOPLE_WHO_STUFF(a, b) {
    a.filter({if (b.indexOf(current item of a) is -1) then
           return false;
              else
           return true;
    });
return a;
}

Hope you liked this, just like I liked documenting another sub-optimal way of getting stuff done :), TTYL!

Tune down LinkedIn noise with JS

Karan — Mon, 29 Oct 2018 06:41:33 +0000

Hi everyone,

I recently realised how much useless likes, follows, shares are on my LinkedIn feed and decided to make a change, by unfollowing several people at once. However LinkedIn doesn't provide this option (or atleast I don't know about it). The method is fairly simple and many people have done this already, but here's my take.

Explore

Go to manage followers page and click on x Following next to Follow fresh perspectives. Hit Inspect on the Following check on any of the people on it. On inspecting you'll see the massive DOM with too much information.

What's it about?

It's just a button which toggles between follow and unfollow.

What do we want to do?

Assuming you want to unfollow everyone. Click on all these Following buttons on this page and that's where JS comes in handy. When you're following someone the button will be of let's say CLASS FOLLOWING and CLASS NOT FOLLOWING otherwise.

What we'll do?

Just loop over all these Following buttons. Check out this link.

How?

In console, this is what you do, while being on the same page. Now this might be kind of stupid/naive way of doing it, but it worked.

//Create a variable that refers to the **CLASS FOLLOWING** buttons on this page.

var follow = document.getElementsByClassName("SEARCH THE CLASS ;)");

//get follow length, that is, how many buttons are there on the current scroll, since they increase when you go down, responsive web design or whatever that is.

var followLength = follow.length;

//loop over all the buttons and click them one by one, thereby unfollowing people.

for(var i =0;i<followLength;i++){
        follow[0].click();
    }

Limitations

Since I'm a JS noob, the follow length updates while the page is scrolled down, this might cause some trouble.
If you're following everyone, like say 500 people like I did, It can just halt chrome to a grind!
I frankly get confused by following/followers page, because followers page also has the same button and then it resets itself, because....I'm not able to explain it, but why can't LinkedIn make it on the same page?!So you might want to check this behaviour out and see how it works for a couple of people.

I tried this because I wanted to unfollow everyone, in case you do, you might want to follow a small set of people who are relevant to your case, otherwise you'll end up checking/unchecking them again manually!

Oh and don't forget to click on the DONE button on top to refresh your feed! :)

Have fun!

Ouch! Oh no, I recursion'd myself!

Karan — Thu, 25 Oct 2018 06:28:14 +0000

Hey Devers!

What's happening? Here's another short post about me cutting myself with concepts I don't know.

This one is about Best Travel from codewars, it's very simple if you code in Python, but in JS(if you're like me) you'll have to bang your head on the table and bang your head on the table and bang your head on the table and...maximum stack size exceeded!😭

Problem:

Get distinct fixed length(say f) combinations from the input array without replacement
Calculate sum of each combination derived from step 1.
Compare each sum with a given input parameter, say K
Return sum closest to K otherwise Null etc.

If you're using python, getting the combination is as easy as follows:

import itertools

arr = [1,2,3,4,5,6,7,8]

combinations = itertools.combinations(arr, 5) # f is 5

#print each combination
for i in combinations:
    print(i)

Check out the post from geeksforgeeks By the way, I just saw this now! lol wut!

So...I didn't know this when I tried this problem and I tried it with JS, looky here, and as you know based on my last post, it's replusive, grotesque!😬

ts = [ 91, 74, 73, 85, 73, 81, 87 ];

function chooseBestSum(t, k, ls){
    var km = t;
    var towns = k;
    var arr = ls;
    var tuple = [];
    var km_sum = [];
    var count = 0;
    var result = 0;
    function karan(arr){
    if(arr.length==0){
        return null;
    }
    else{
        if(tuple.length===towns-1){
            for(var i =0;i<arr.length;i++){
                tuple[towns-1]=arr[i];
                console.log('we are here', tuple);
                km_sum.push(tuple.reduce((i,c)=>i+c));
            }
            //tuple.splice(1,2)
            tuple.splice(1,tuple.length);
        }
        tuple.push(arr[0]);
        karan(arr.slice(count+1, arr.length));
    }
    //return Math.max(...km_sum.filter(i=>i<=km?i:null))
    }

    for(var i = 0;i<=arr.length-towns;i++){
        tuple = [];
        karan(arr.slice(i,arr.length));
    };
    console.log(km_sum);
    result = Math.max(...km_sum.filter(i=>i<=km)); 
    if(result===-1 || result===-Infinity){
        return null;
    }
    else{
        return result;
    }
    //result = Math.max(...km_sum.filter(i=>(km_sum.length>0&&i<=km)?i:null));
}

chooseBestSum(331, 4, ts);

What I'm trying to do:

Thinking too much that only RECURSION will solve it! WRONG! Although it is the best and shortest solution.
Not able to really visualize the problem.
Never read or discovered what this is, until I saw the stuff online
Absolutely confused about where function returns would work etc.

And so I wasn't able to solve it myself! The code you see above works 22/30 times because it does not return all the correct combinations BECAUSE it's a hit and miss BECAUSE it was primarily fashioned for f = 3! 😳😳😳😳

And I leave you all with this : RTFM, train again and a quote from Scott Eastwood:

Keep your head down, work hard, and don't ever believe your own hype, because... you just keep working.

Good Day!

Clean code and why I'm behind!

Karan — Thu, 18 Oct 2018 05:07:03 +0000

Hello everyone,

This is my first post here, so I'll try & keep it short😃. I've recently started sharpening my javascript axe on Codewars after several days working on Watch & Code by Gordon Zhu, which is amazing first step to get started with JS since I knew nothing, still don't know much, anyway to the point...

There's kata on codewars, an easier one for the experts, but this one is at 6 kyu and it goes like this:

Given a list lst and a number N, create a new list that contains each number of lst at most N times without reordering. For example if N = 2, and the input is [1,2,3,1,2,1,2,3], you take [1,2,3,1,2], drop the next [1,2] since this would lead to 1 and 2 being in the result 3 times, and then take 3, which leads to [1,2,3,1,2,3].

So essentially, you need to remove the Nth occurance of a digit without spoiling the indexes.

Easy right? I know now! Not last week when I nearly spent 3 days (please don't judge me) breaking my head when I should've just thought about it clearly and read the filter function documentation clearly.

Now for the depressingly bad code I wrote, in retrospect I am ashamed!😓

function deleteNth(arr, n){
    var final = [];
    var last = [];
    var k = [];
    var f = [];
    var count_inside = 0;

    arr.forEach(function(item, index){
        if(last.indexOf(item)===-1){
            final[index] = arr.map(i=>{
                if(i===item && count_inside<n){
                    count_inside +=1;
                    return item;
                }
                else{
                    return '';
                }
            }
            );
            count_inside = 0;
            last.push(item);
        }
    });

    k = final.filter(function(i){return true;})

    for(var i =0;i<arr.length;i++){
        var sum = '';
        for(var j = 0;j<k.length;j++){
            sum += k[j][i];
        }
        f.push(parseInt(sum));
    }
    return f.filter(function(p){return p>=p});
}

I'm essentially trying to do the following:

Filter the array with a number, and get the result in an array with that number and all other indexes as empty or ''.
Do this other numbers without repeating the number from step 1.
Compress the resulting arrays into a single one and BOOM SERVE!

While still proud submitting it...knowing fully well that someone might have done it in a single LINE! And yeah after submission...I see this:

function deleteNth(arr,x) {
  var result = [];
  return arr.filter(function(n) {
    result[n] = (result[n]||0) + 1;
    return result[n] <= x;
  });
}

That's all it took!

Just count the times a number appeared and if it appeared more than N times, don't put it in the returned array.

And I missed that! I understand it will take me somewhile to think that clearly.
But I just wanted to put this out and maybe it might help you think in a different way today :).

Thank you Codewars!