A Computer Science senior at TIET.

JASKIRAT SINGH

Divider

Recent posts

![](https://miro.medium.com/max/828/0\*M2j_Ir5aef7Dmcrl)

Photo by [*Olav Ahrens Røtne*](https://unsplash.com/@olav_ahrens?utm_source=medium\&utm_medium=referral) on [*Unsplash*](https://unsplash.com/?utm_source=medium\&utm_medium=referral)

`Some people like to think of computational thinking as something directly related to coding or programming, but its not just about programming. Its an approach to developing solutions to problems using concepts and ideas from Computer Science.`

`To put it simply, Computational thinking involves breaking down problems into subproblems, looking for patterns or similarities, identifying important details, and developing a plan of action.`

`This broad problem-solving technique is branched into: Decomposition, Pattern Recognition, Data Representation and Abstraction, Algorithms. These are what we call the undefined of Computational thinking.`

`Let’s take a look at each one of them:`

**Decomposition:**

`The process of breaking down a complex problem into less complex or more manageable subproblems.`

`Complex problems can be overwhelming but can be dealt with if broken down into subproblems that are comparatively easier to solve. The solutions to these manageable subproblems can then be merged to solve the original complex problem.`

**Pattern Recognition:**

`When we decompose the problem, we find patterns among the subproblems (similarities or shared characteristics). Discovering these patterns make the complex problem easier to solve since we can use the same solution for each occurrence of the pattern.`

**Data Representation and Abstraction:**

`It involves determining what characteristics of the problem are important and filtering out those that are not. We use these important characteristics to create a representation of our problem at hand. These important characteristics are determined keeping in mind our objective while dealing with the task/subproblem and help us focus on the bigger picture.`

**Algorithms:**

`A set of step-by-step instructions of solving the problem.`

`An algorithm is, in some sense the pinnacle of computational thinking, and builds on decomposition, pattern recognition, and data abstraction. By describing how the problem is to be solved in a step by step manner, an algorithm identifies what is to be done, the instructions, and the order in which they should be done.`

***References:***

<https://www.coursera.org/learn/computational-thinking-problem-solving>

##### [Read post on Medium](https://medium.com/@jjaskirat.ssingh/understanding-the-four-pillars-of-computational-thinking-66d2289e3aae)



Understanding the four pillars of Computational Thinking

# ![](https://miro.medium.com/max/875/0\*o3dZxb4OU0koIDos)

*Photo by David Rangel on Unslash*

`As we set out our foot in the field of Data Science, we are tempted to commit a mistake that might go unnoticed at first but it might be the sole reason of our model performing poorly in production.`

***The mistake:***

```
X_test = imputer.fit_transform(X_test)
```

`Do you see something wrong here?`

`Before we jump right into the explanation of what is happening here, let’s see what fit_transform() method does and how is it different from transform() method.`

**fit_transform():**

`This method is used on our train data to learn the training parameters (the mean and the variance of the features of training set) which are further used to scale our test data.`

> `undefined fit_transform() is equivalent to using fit() and transform() methods in order.`

**transform():**

`This method uses the training parameters learned on the train data to scale the test data.`

`So what is it that we were doing wrong in the above code snippet?`

`We are unknowingly passing information from our train set to our validation set. This is called `**Train-Test contamination** *(Data Leakage)*.

`Surprisingly, this mistake shall give you excellent results during model training. This is because by using fit method on our validation set, we compute a new mean and variance for the validation set and let our model learn about it (making it a biased model), which should never have been done in the first place as the validation set (or test data) should come as a “surprise” to our model.`

`So how do we scale our test data then? This is where the transform() method comes into picture. It uses the learnings from the training data to transform the testing data or the validation set.`

`It is common practice to scale the data so that the model is not biased towards any particular feature of the dataset, simultaneously ensuring that our model does not learn about our validation set (or test data).`

`Thus, the correct way:`

```
X_train = imputer.fit_transform(X_train)
X_test = imputer.transform(X_test)
```



[READ POST ON MEDIUM](https://medium.com/@jjaskirat.ssingh/why-we-shouldnt-call-fit-transform-method-on-our-validation-set-or-test-data-73720792ab3e)


Home

JASKIRAT SINGH

Understanding the four pillars of Computational Thinking

Why we shouldn’t call fit_transform method on our test data?