Nat  Kutch

Nat Kutch

1598684280

What is False Positives , False Negatives , True Positives 

False Positives(FP) , False Negatives(FN) , True Positives(TP) and True Negatives(TN) are the kind of evaluation metrics which are used to define difference between the prediction made by Humans( technically named as Ground Truth) and Machines(technically known as Result of Method).

Consider the above image in order to have better understanding of the concepts. Here we have taken an example of edge detection done for any image.

The edge predicted by Humans is marked in red circle (also known as Ground truth[GT]) . Also the prediction of edge made by the machine is marked in blue circle(also known as Results of Method [ROM]).

In the above scenario we can say that the intersection of GT and ROM i.e. region A is the correct estimation of presence of edge by machine and human and hence it is called True Positives.

In the second case we can consider that the region D which is not under both GT and ROM is the area which is not containing edges in the original image as per both machine and human and it is known as True Negatives.

#correlation #data-science #data analysis

What is GEEK

Buddha Community

What is False Positives , False Negatives , True Positives 
Nat  Kutch

Nat Kutch

1598684280

What is False Positives , False Negatives , True Positives 

False Positives(FP) , False Negatives(FN) , True Positives(TP) and True Negatives(TN) are the kind of evaluation metrics which are used to define difference between the prediction made by Humans( technically named as Ground Truth) and Machines(technically known as Result of Method).

Consider the above image in order to have better understanding of the concepts. Here we have taken an example of edge detection done for any image.

The edge predicted by Humans is marked in red circle (also known as Ground truth[GT]) . Also the prediction of edge made by the machine is marked in blue circle(also known as Results of Method [ROM]).

In the above scenario we can say that the intersection of GT and ROM i.e. region A is the correct estimation of presence of edge by machine and human and hence it is called True Positives.

In the second case we can consider that the region D which is not under both GT and ROM is the area which is not containing edges in the original image as per both machine and human and it is known as True Negatives.

#correlation #data-science #data analysis

How To Deal With Imbalanced Classification

In machine learning, when building a classification model with data having far more instances of one class than another, the initial default classifier is often unsatisfactory because it classifies almost every case as the majority class. Most of us are familiar with the fact that the ordinary classification accuracy score (% classified correctly) is not useful in the highly-imbalanced (skewed) case because it can trivially approach 100%, and it gives equal weight to false positives and false negatives. Many articles show you how to use oversampling (e.g. SMOTE) or sometimes class-based sample weighting to retrain the model, but this isn’t always necessary (and it also biases/distorts the numeric probability predictions of the model so that they become miscalibrated to the original and future data). Here we aim instead to show how much you can do **without **balancing the data or retraining the model, and how it gives you the flexibility to make any desired trade-off between false positives and false negatives.

We will use the credit card fraud identification data set from Kaggle to illustrate. Each row of the data set represents a credit card transaction, with the target variable Class==0 indicating a legitimate transaction and Class==1 indicating that the transaction turned out to be a fraud. There are 284,807 transactions, of which only 492 (0.173%) are frauds — very imbalanced indeed.

We will use a gradient boosting classifier because these often give good results. Specifically Scikit-Learn’s new HistGradientBoostingClassifier because it is much faster than their original GradientBoostingClassifier when the data set is relatively large like this one.

First let’s import some libraries and read in the data set.

import numpy as np
import pandas as pd
from sklearn import model_selection, metrics
from sklearn.experimental import enable_hist_gradient_boosting
from sklearn.ensemble import HistGradientBoostingClassifier
df=pd.read_csv('creditcard.csv')
df.info()

Image for post

V1 through V28 (from a principal components analysis) and the transaction Amount are the features, which are all numeric and there is no missing data. Because we are only using a tree-based classifier, we don’t need to standardize or normalize the features.

We will now train the model after splitting the data into train and test sets. This took about half a minute on my laptop. We use the n_iter_no_change to stop the training early if the performance on a validation subset starts to deteriorate due to overfitting. I separately did a little bit of hyperparameter tuning to choose the learning_rate and max_leaf_nodes, but this is not the focus of the present article.

Xtrain, Xtest, ytrain, ytest = model_selection.train_test_split(
        df.loc[:,'V1':'Amount'], df.Class,  stratify=df.Class, 
        test_size=0.3, random_state=42)
gbc=HistGradientBoostingClassifier(learning_rate=0.01, 
        max_iter=2000, max_leaf_nodes=6, validation_fraction=0.2, 
        n_iter_no_change=15, random_state=42).fit(Xtrain,ytrain)

Now we apply this model to the test data as the default hard-classifier, predicting 0 or 1 for each transaction. We are implicitly applying decision threshold 0.5 to the model’s probability prediction as a soft-classifier. When the probability prediction is over 0.5 we say “1” and when it is under 0.5 we say “0”.

#imbalanced-data #classification #machine-learning #false-positive #false-negative

Terry  Tremblay

Terry Tremblay

1603069080

False positives Are Considered Enemies, But Can They Be Your Friends?

When writing a rule for static analysis, it’s possible that in some cases, the rule does not give the results that were expected. Unfortunately, naming a false positive is often far easier than fixing it. In this post, I’ll discuss how the different types of rules give rise to different types of false positives, which ones are easier to fix than others, and how you can help. I’ll end with insight into how issues that are false positives can still be true indicators that the code needs to change.

First let’s take a look at what “false positive” means. There are two questions which shape the definition. First, is there a real issue in the code? Second, is an issue detected in the code? Combining them gives us a 2x2 Cartesian matrix:

Why are there false positives?

There are several kinds of rules, that rely on different analysis techniques. It therefore comes as no surprise that there are different reasons for false positives.

One important distinction is whether the rule needs to compute the semantic properties of your program (For instance: Can this string be empty? Is it possible for a call to function b to happen before a call function a? …​), or if it just needs to rely on syntactic properties (Is the program using goto? Does this switch handle all possible values of an enum? …​). Let’s look at the impact this difference has.

Rice’s theorem

Rice’s theorem says that any non-trivial semantic property of a program is undecidable. A very well-known special case of this theorem is the halting problem, which was proven impossible to solve by Alan Turing. There is no way to write a rule that can detect, given the source code of another program, whether this other program will stop or run indefinitely.

Fortunately, these theorems don’t mean that static analysis is doomed to fail. There are heuristics that work reasonably well in many useful cases. It’s just not possible to write something that will work in all cases. Rules that rely on semantic properties will always be subject to false positives.

#cpp #static-analysis #hackernoon-top-story #false-positives-cpp #c#

Why `True is False is False` -> False?

Python is cool: after so many years of using it, there are these little peculiar things that amaze me. I recently stumbled upon a very simple line of code that most of the experienced python programmers I know could not explain without googling it.
WTF…
Why is it surprising? I think because that’s not what a human would output if he were asked to execute this command. Here is how I reasoned about it.
I need to execute the first is statement, which would give meFalse and then execute the second is which would give me True. Equivalently:

#funny #programming #python #python3

Abigail  Cassin

Abigail Cassin

1594030740

Positioning with CSS

To continue our lessons with CSS, an important skill to have as a budding developer is the ability to position and place your contents on your site. When you start to build more complicated websites and apps you’re going to have multiple layers that need to be able to interact with each other without disturbing the flow. In this brief article, we’re going to go over the four main ways to position items on your page, as well as a fifth piece of information that his greatly helpful.

Remember that this can all be done when writing in CSS and doesn’t require you to change what is happening in your HTML. While it does sometimes have to do with your

s or other groupings in your HTML, this is a simple introduction which requires very simple code input to change the position of certain elements only in your CSS file.

As pictured above, the four main ways to position your contents on the site are staticrelativeabsolute, and fixed. We will run through each of these quickly to learn how they can each be used effectively!

Static

When adding new blocks, or pieces of content to your site or app, you will be adding items from the top left of the page downward. This is the default positioning, and make it so that each item doesn’t overlap with each other. This is done simply by writing in “position: static;” in your CSS element, or by not signifying (as it’s the default). These static elements can be paired with a width and height, but otherwise they are simply placed in the site without overlapping.

#css #positioning #programming