# Mastering Linear Regression: The Definitive Information For Aspiring Information Scientists | Federico Trotta

## All you must learn about Linear Regression is right here (together with an utility in Python)

If you’re approaching Machine Studying, one of many first fashions it’s possible you’ll encounter is Linear Regression. It’s in all probability the best mannequin to know, however don’t underestimate it: there are a whole lot of issues to know and grasp.

If you happen to’re a newbie in Information Science or an aspiring Information Scientist, you’re in all probability going through some difficulties as a result of there are a whole lot of assets on the market, however are fragmented. I understand how you’re feeling, and for this reason I created this whole information: I need to offer you all of the data you want with out trying to find anything.

So, if you wish to have full data of Linear Regression this text is for you. You possibly can research it deeply and re-read it everytime you want it probably the most. Additionally, think about that, to cowl this subject, we’ll want some data typically related to regression evaluation: we’ll cowl it in deep.

And…you’ll excuse me if I’ll hyperlink a useful resource you’ll want: prior to now, I’ve created an article on some matters associated to Linear Regression so, to have an entire overview, I counsel you to learn it (I’ll hyperlink later after we’ll want it).

**Desk of Contents:**What can we imply by "regression evaluation"?

Understanding correlation

The distinction between correlation and regression

The Linear Regression mannequin

Assumptions for the Linear Regression mannequin

Discovering the road that most closely fits the information

Graphical strategies to validate your mannequin

An instance in Python

Right here we’re learning Linear Regression, however what can we imply by “regression evaluation”? Paraphrasing from Wikipedia:

Regression evaluation is a mathematical approach used to discover a practical relationship between a dependent variable and a number of unbiased variable(s).

In different phrases, we all know that in arithmetic we will outline a operate like so: `y=f(x)`

. Usually, `y`

known as the dependent variable and `x`

the unbiased. So, we categorical `y`

in relationship with `x`

, utilizing a sure operate `f`

. The purpose of regression evaluation is, then, to search out the operate `f`

.

Now, this appears simple however shouldn’t be. And I do know you understand it. And the explanation why shouldn’t be simple is:

- We all know
`x`

and`y`

. For instance, if we’re working with tabular information (with`Pandas`

, for instance)`x`

are the options and`y`

is the label. - Sadly, the information not often observe a really clear path. So our job is to search out the very best operate
`f`

that**approximates**the connection between`x`

and`y`

.

So, let me summarize it: regression evaluation goals to search out an estimated relationship (a superb one!) between the dependent and the unbiased variable(s).

Now, let’s visualize why this course of could also be troublesome. Think about the next code and its consequence:

`import numpy as np`

import matplotlib.pyplot as plt# Create random linear information

a = 130

x = 6*np.random.rand(a,1)-3

y = 0.5*x+5+np.random.rand(a,1)

# Labels

plt.xlabel('x')

plt.ylabel('y')

# Plot a scatterplot

plt.scatter(x,y)

Now, inform me: can the connection between `x`

and `y`

be a line? So…can this information be approximated by a line? Like the next, for instance:

Cease studying for a second and take into consideration that.

Effectively, it might. And the way concerning the following one?

Effectively, even this might! So, what’s the very best one? And why not one other one?

That is the purpose of regression: to search out the best-estimated operate that may approximate the given information. And it does so utilizing some methodologies: we’ll cowl them later on this article. We’ll apply them to the Linear Regression mannequin however a few of them can be utilized with another regression approach. Don’t fear: I’ll be very particular so that you don’t get confused.

Quoting from Wikipedia:

In statistics, correlation is any statistical relationship, whether or not causal or not, between two random variables. Though within the broadest sense, “correlation” might point out any sort of affiliation, in statistics it normally refers back to the diploma to which a pair of variables are linearly associated.

In different phrases, **correlation** is a statistical measure that expresses the **linear relationship between variables**.

We will say that two variables are correlated if every worth of the primary variable corresponds to a price for the second variable, following a path. If two variables are extremely correlated, the trail could be linear, as a result of the correlation describes the linear relation between the variables.

## The maths behind the correlation

This can be a complete information, as promised. So, I need to cowl the maths behind the correlation, however don’t fear: we’ll make it simple with the intention to perceive it even for those who’re not specialised in math.

We typically check with the correlation coefficient, often known as the **Pearson correlation coefficient**. This provides an estimate of the correlation between two variables. Suppose now we have two variables, `a`

and `b`

and so they can attain `n`

values. We will calculate the correlation coefficient as follows:

The place now we have:

- the imply worth of
`a`

(nevertheless it applies to each variables,`a`

and`b`

):

If now we have a 0 correlation coefficient, it implies that the information factors don’t have a tendency to extend or lower following a linear path, as a result of now we have no correlation.

Allow us to take a look at some plots of correlation coefficients with completely different values (picture from Wikipedia here):

As we will see, when the correlation coefficient is the same as 1 or -1 the tendency of the information factors is clearly to be alongside a line. However, because the correlation coefficient deviates from the 2 excessive values, the distribution of the information factors deviates from a linear path. Lastly, for the correlation coefficient of 0, the distribution of the information might be something.

So, after we get a correlation coefficient of 0 we will’t say something concerning the distribution of the information, however we will examine it (if wanted) with a regression evaluation.

So, correlation and regression are linked however are completely different:

- Correlation analyzes the tendency of variables to be linearly distributed.
- Regression is the research of the connection between variables.

We now have two sorts of Linear Regression fashions: the Easy and the A number of ones. Let’s see them each.

## The Easy Linear Regression mannequin

The purpose of the Easy Linear Regression is to mannequin the connection between a single function and a steady label. That is the mathematical equation that describes this ML mannequin:

`y = wx + b`

The parameter `b`

(additionally referred to as “bias”) represents the y-axis intercept (is the worth of `y`

when `X=0`

), and `w`

is the burden coefficient. Our purpose is to study the burden `w`

that describes the connection between `x`

and `y`

. This weight will later be used to foretell the response for brand spanking new values of `x`

.

Let’s think about a sensible instance:

`import numpy as np`

import matplotlib.pyplot as plt# Create information

x = np.array([1, 1, 2, 3, 4, 4, 5, 6, 7, 7, 8, 9])

y = np.array([13, 14, 17, 12, 23, 24, 25, 25, 24, 28, 32, 33])

# Present scatterplot

plt.scatter(x, y)

The query is: can this information distribution be approximated with a line? Effectively, we might create one thing like that:

`import numpy as np`

import matplotlib.pyplot as plt# Create information

x = np.array([1, 1, 2, 3, 4, 4, 5, 6, 7, 7, 8, 9])

y = np.array([13, 14, 17, 12, 23, 24, 25, 25, 24, 28, 32, 33])

# Create primary scatterplot

plt.plot(x, y, 'o')

# Receive m (slope) and b (intercept) of a line

m, b = np.polyfit(x, y, 1)

# Add linear regression line to scatterplot

plt.plot(x, m*x+b)

# Labels

plt.xlabel('x variable')

plt.ylabel('y variable')

Effectively, as within the instance we’ve seen above, it could possibly be a line nevertheless it could possibly be a normal curve.

And, in a second we’ll see how we will say if the information distribution might be higher described by a line or by a normal curve.

## The A number of Linear Regression mannequin

Since actuality is advanced, the standard circumstances we’ll face are associated to the A number of Linear Regression case. We imply that the function `x`

shouldn’t be a single one: we’ll have a number of options. For instance, if we work with tabular information, an information body with 9 columns has 8 options and 1 label: which means that our drawback is eight-dimensional.

As we will perceive, this case may be very difficult to visualise and the equation of the road must be expressed with vectors and matrices, changing into:

So, the equation of the road turns into the sum of all of the weights (`w`

) multiplied by the unbiased variable (`x`

) and it might even be written because the product of two matrices.

Now, to use the Linear Regression mannequin, our information ought to respect some assumptions. These are:

**Linearity**: the connection between the dependent variable and unbiased variables needs to be linear. Which means a change within the unbiased variable ought to lead to a proportional change within the dependent variable, following a linear path.**Independence**: the observations within the dataset needs to be unbiased of one another. Which means the worth of 1 remark mustn’t depend upon the worth of one other remark.**Homoscedasticity**: the variance of the residuals needs to be fixed throughout all ranges of the unbiased variable. In different phrases, the unfold of the residuals needs to be roughly the identical throughout all ranges of the unbiased variable.**Normality**: the residuals needs to be usually distributed. In different phrases, the distribution of the residuals needs to be a standard (or bell-shaped) curve.**No multicollinearity**: the unbiased variables shouldn’t be extremely correlated with one another. If two or extra unbiased variables are extremely correlated, it may be troublesome to tell apart the person results of every variable on the dependent variable.

Sadly, testing all these hypotheses shouldn’t be all the time potential, particularly within the case of the A number of Linear Regression mannequin. Anyway, there’s a solution to take a look at all of the hypotheses. It’s referred to as the `p-value`

take a look at, and possibly you heard of that earlier than. Anyway, we received’t cowl this take a look at right here for 2 causes:

- It’s a normal take a look at, not particularly associated to the Linear Regression mannequin. So, it wants a particular remedy in a devoted article.
- I’m a kind of (possibly one of many few) who believes that calculating the
`p-value`

shouldn’t be all the time a should when we have to analyze information. Because of this, I’ll create sooner or later a devoted article on this controversial subject. However only for the sake of curiosity, since I’m an engineer I’ve a really sensible strategy, and I like utilized arithmetic. I wrote an article on this subject right here:

So, above we had been reasoning which one of many following might be the very best match:

To know if the very best mannequin is the left one (the road) or the best one (a normal curve) we proceed as follows:

- We break up the information now we have into the coaching and the take a look at set.
- We validate each fashions on each units, testing how properly our fashions generalize their studying.

We received’t cowl the polynomial mannequin right here (helpful for normal curves), however think about that there are two approaches to validate ML fashions:

- The analytical one.
- The graphical one.

Usually talking, we’ll use each to get a greater understanding of the efficiency of the mannequin. Anyway, **generalizing **implies that our ML mannequin learns from the coaching set and **applies accurately its studying to the take a look at set**. If it would not, we attempt one other ML mannequin. Right here’s the method:

Which means **an ML mannequin generalizes properly when it has good performances on each the coaching and the take a look at set**.

I’ve mentioned the analytical solution to validate an ML mannequin within the case of linear regression within the following article:

I counsel you to learn it as a result of we’ll use some metrics mentioned there within the instance on the finish of this text.

In fact, the metrics mentioned might be utilized to any ML mannequin within the case of a regression drawback. However you’re fortunate: I’ve used the linear mannequin for example.

The graphical methods to validate an ML mannequin within the case of a regression drawback are mentioned within the subsequent paragraph.

Let’s see three graphical methods to validate our ML fashions.

## 1. The residual evaluation plot

This methodology is particular to the Linear Regression mannequin and consists in visualizing how the residuals are distributed. Right here’s what we count on:

To plot this we will use the built-in operate `sns.residplot()`

in `Seaborn`

(here’s the documentation).

A plot like that’s good as a result of we need to see randomly distributed information factors alongside the horizontal axis. One of many **assumptions of the linear regression mannequin**, in reality, is that the **residuals have to be usually distributed **(assumption n°4 listed above). If the residuals are usually distributed, it implies that the errors of the noticed values from the expected ones are randomly distributed round zero, with no clear sample or pattern; and that is precisely the case in our plot. So, in these circumstances, our ML mannequin could also be a superb one.

As an alternative, if there’s a specific sample in our residual plot, our mannequin shouldn’t be good for our ML drawback. For instance, think about the next:

On this case, we will see that there’s a parabolic pattern: which means that our mannequin (the Linear mannequin) shouldn’t be good to unravel our ML drawback.

## 2. The precise vs. predicted values plot

One other plot we might use to validate our ML mannequin is the **precise vs. predicted plot**. On this case, we plot a graph having the precise values on the horizontal axis and the expected values on the vertical axis. The purpose is to search out the information factors distributed as a lot as potential to a line, within the case of Linear Regression. We will even use the strategy within the case of a polynomial regression: on this case, we’d count on the information distributed as a lot as potential to a generic curve.

Suppose now we have a outcome as follows:

The above graph reveals that the expected information factors are distributed alongside a line. It’s not an ideal linear distribution, so the linear mannequin is probably not ultimate.

If, for our particular drawback, now we have`y_train`

(the label on the coaching set) and we’ve calculated `y_train_pred`

(the prediction on the coaching set), we will plot the next graph like so:

`import matplotlib.pyplot as plt`# Scatterplot of y_train and y_train_pred

plt.scatter(y_train, y_train_pred)

plt.plot(y_test, y_test, shade='r') # Plot the road

# Labels

plt.title('ACTUAL VS PREDICTED VALUES')

plt.xlabel('ACTUAL VALUES')

plt.ylabel('PREDICTED VALUES')

## 3. The Kernel Density Estimation (KDE) plot

The final graph we need to speak about to validate our ML fashions is the Kernel Density Estimation (KDE) plot. This can be a normal methodology and can be utilized to validate each regression and classification fashions.

The KDE is the appliance of a **kernel smoother** for likelihood density estimation. A kernel smoother is a statistical methodology that’s used to estimate a operate because the weighted common of the neighbor noticed information. The kernel defines the burden, giving a better weight to nearer information factors.

To know the usefulness of a smoother operate, see the graph beneath:

It’s useful to approximate our information factors with a smoothing operate if we need to examine two portions. Within the case of an ML drawback, in reality, we usually wish to see the comparability between the precise labels and the labels predicted by our mannequin, so we use the KDE to match two smoothed features.

Let’s say now we have predicted our labels utilizing a linear regression mannequin. We need to examine the KDE for our coaching set’s precise and predicted labels. We will accomplish that with `Seaborn`

invoking the strategy `sns.kdeplot()`

(here’s the documentation).

Suppose now we have the next outcome:

As we will see, the comparability between the precise and the expected label is simple to do, since we’re evaluating two smoothed features; in a case like that, our mannequin is nice as a result of the curves are very comparable.

Actually, what we count on from a “good” ML mannequin are:

- The curves are just like bell curves, as a lot as potential.
- The 2 curves are comparable between them, as a lot as potential.

Now, let’s apply all of the issues we’ve realized to this point right here. We’ll use the well-known “Ames Housing” dataset, which is ideal for our scopes.

This dataset has 80 options, however for simplicity, we’ll work with only a subset of them that are:

`General Qual`

: it’s the score of the general materials and end of the home on a scale from 1 (dangerous) to 10 (glorious).`General Cond`

: it’s the score of the general situation of the home on a scale from 1 (dangerous) to 10 (glorious).`Gr Liv Space`

: it’s the above-ground dwelling space, measured in squared ft.`Complete Bsmt SF`

: it’s the complete basement space, measured in squared ft.`SalePrice`

: it’s the sale worth, in USD $.

We’ll think about our `SalePrice`

column because the goal (label) variable, and the opposite columns because the options.

## Exploratory Information Evaluation EDA

Let’s import our information, create a subset with the talked about options, and show some statistics:

`import pandas as pd`# Outline the columns

columns = ['Overall Qual', 'Overall Cond', 'Gr Liv Area',

'Total Bsmt SF', 'SalePrice']

# Create dataframe

df = pd.read_csv('http://jse.amstat.org/v19n3/decock/AmesHousing.txt',

sep='t', usecols=columns)

# Present statistics

df.describe()

An essential remark right here is that the imply values for all labels have a special vary (the `General Qual`

imply worth is `6.09`

whereas `Gr Liv Space`

imply worth is `1499.69`

). This tells us an essential reality: now we have to scale the options.

## Information preparation

What does “**options scaling**” imply?

Scaling a function implies that the function vary is scaled between 0 and 1 or between 1 and -1. There are two typical strategies to scale the options:

**Imply normalization:**Imply normalization is a technique of scaling numeric information in order that it has a minimal worth of zero and a most worth of every person the values are normalized across the imply worth. Suppose*c*is a price reached by our function; to scale across the imply (*c*′ is the brand new worth of*c*after the normalization course of):

Let’s see an instance in Python:

`import numpy as np`# Create an inventory of numbers

information = [1, 2, 3, 4, 5]

# Discover min and max values

data_min = min(information)

data_max = max(information)

# Normalize the information

data_normalized = [(x - data_min) / (data_max - data_min) for x in data]

# Print the normalized information

print(f'normalized information: {data_normalized}')

>>>

normalized information: [0.0, 0.25, 0.5, 0.75, 1.0]

**Standardization**(or z-score normalization): This methodology transforms a variable in order that it has a imply of zero and an ordinary deviation of 1. The components is the next (c′c’c′ is the brand new worth of ccc after the normalization course of):

Let’s see an instance in Python:

`import numpy as np`# Authentic information

information = [1, 2, 3, 4, 5]

# Calculate imply and commonplace deviation

imply = np.imply(information)

std = np.std(information)

# Standardize the information

data_standardized = [(x - mean) / std for x in data]

# Print the standardized information

print(f'standardized values: {data_standardized}')

print(f'imply of standardized values: {np.imply(data_standardized)}')

print(f'std. dev. of standardized values: {np.std(data_standardized): .2f}')

>>>

standardized values: [-1.414213562373095, -0.7071067811865475, 0.0, 0.7071067811865475, 1.414213562373095]

imply of standardized values: 0.0

std. dev. of standardized values: 1.00

As we will see, the normalized information have a imply of 0 and an ordinary deviation of 1, as we wished. The excellent news is that we will use the library `scikit-learn`

to standardize the options, and we will do it in a second.

Options scaling is a crucial factor to do when engaged on an ML drawback, for a easy purpose:

- If we carry out exploratory information evaluation with options that aren’t scaled, when calculating the imply values (for instance, in the course of the calculation of the coefficient of correlation) we’ll get numbers which might be very completely different from one another. If we check out the statistics we’ve bought above after we’ve invoked the
`df.describe()`

methodology, we will see that, for every column, we get a really completely different worth of the imply. If we scale or normalize the options, as a substitute, we’ll get 0s, 1s, and -1s: and it will assist us mathematically.

Now, this dataset has some `NaN`

values. We received’t present it for brevity (attempt it by yourself), however we’ll take away them. Additionally, we’ll calculate the correlation matrix:

`import seaborn as sns`

import matplotlib.pyplot as plt

import numpy as np# Drop NaNs from dataframe

df = df.dropna(axis=0)

# Apply masks

masks = np.triu(np.ones_like(df.corr()))

# Warmth map for correlation coefficient

sns.heatmap(df.corr(), annot=True, fmt="0.1", masks=masks)

So, with `np.triu(np.ones_like(df.corr()))`

now we have created a masks that it’s helpful to show a triangular correlation matrix, which is extra readable (particularly when now we have way more options than on this case).

So, there’s a reasonable `0.6`

correlation between `Complete Bsmt SF`

and `SalePrice`

, fairly a excessive `0.7`

correlation between `Gr Liv Space`

and `SalePrice`

, and a excessive correlation `0.8`

between `General Qual`

and `SalePrice`

; Additionally, there’s a reasonable correlation between `General Qual`

and `Gr Liv Space`

`0.6`

and `0.5`

between `General Qual`

and `Complete Bsmt SF`

.

Right here there’s no multicollinearity, so no options are extremely correlated with one another (so, our options fulfill the speculation n°5 listed above). If we’d discovered some extremely correlated options, we might delete them as a result of **two extremely correlated options have the identical impact on the label **(**this is applicable to each normal ML mannequin: if two options are extremely correlated, we will drop one of many two**).

Lastly, we subdivide the information body `df`

into `X`

( the options) and `y`

(the label) and scale the options:

`from sklearn.preprocessing import StandardScaler`# Outline the options

X = df.iloc[:,:-1]

# Outline the label

y = df.iloc[:,-1]

# Scale the options

scaler = StandardScaler() # Name the scaler

X = scaler.fit_transform(X) # Match the options to scale them

## Becoming the linear regression mannequin

Now now we have to separate the options `X`

into the coaching and the take a look at set and we’re becoming them with the Linear Regression mannequin. Then, we calculate R² for each units:

`from sklearn.model_selection import train_test_split`

from sklearn.linear_model import LinearRegression

from sklearn import metrics# Cut up

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Match the LR mannequin

reg = LinearRegression().match(X_train, y_train)

# Calculate R^2

coeff_det_train = reg.rating(X_train, y_train)

coeff_det_test = reg.rating(X_test, y_test)

# Print metrics

print(f" R^2 for coaching set: {coeff_det_train}")

print(f" R^2 for take a look at set: {coeff_det_test}")

>>>

R^2 for coaching set: 0.77

R^2 for take a look at set: 0.73

**Notes:**

1) your outcomes might be barely completely different as a result of stocastical

nature of the ML fashions.2) right here we will see generalization on motion:

we fitted the Linear Regression mannequin to the practice set with

*reg = LinearRegression().match(X_train, y_train)*.

The, we have calculated R^2 on the coaching and take a look at units with:

*coeff_det_train = reg.rating(X_train, y_train)*

coeff_det_test = reg.rating(X_test, y_test

In different phrases: we do not match the information to the take a look at set.

We match the information to the coaching set and we calculate the scores

and predictions (see subsequent snippet of code with KDE) on each units

to see the generalization of our modelon new unseen information

(the information of the take a look at set).

So we get R² of 0.77 on the coaching take a look at and 0.73 on the take a look at set that are fairly good, suggesting the Linear mannequin is an effective one to unravel this ML drawback.

Let’s see the KDE plots for each units:

`# Calculate predictions`

y_train_pred = reg.predict(X_train) # practice set

y_test_pred = reg.predict(X_test) # take a look at set# KDE practice set

ax = sns.kdeplot(y_train, shade='r', label='Precise Values') #precise values

sns.kdeplot(y_train_pred, shade='b', label='Predicted Values', ax=ax) #predicted values

# Present title

plt.title('Precise vs Predicted values')

# Present legend

plt.legend()

`# KDE take a look at set`

ax = sns.kdeplot(y_test, shade='r', label='Precise Values') #precise values

sns.kdeplot(y_test_pred, shade='b', label='Predicted Values', ax=ax) #predicted values# Present title

plt.title('Precise vs Predicted values')

# Present legend

plt.legend()

No matter the truth that we’ve obtained an R² of 0.73 on the take a look at set which is nice (however keep in mind: the upper, the higher), this plot reveals us that the linear mannequin is certainly a superb mannequin to unravel this ML drawback. This is the reason I really like the KDE plot: is a really highly effective device, as we will see.

Additionally, this reveals why should not depend on only one methodology to validate our ML mannequin: a mix of 1 analytical methodology with one graphical one typically provides us the best insights to determine whether or not to vary our ML mannequin or not. On this case, the Linear Regression mannequin is ideal to make predictions.

I hope you’ll discover helpful this text. I do know it’s very lengthy, however I wished to present you all of the data you want on this subject, with the intention to return to it everytime you want it probably the most.

A number of the issues we’ve mentioned listed below are normal matters, whereas others are particular to the Linear Regression mannequin. Let’s summarize them:

- The definition of
**regression**is, after all, a normal definition. **Correlation**is usually known as the Linear mannequin**.**Actually, as we stated earlier than, correlation is the tendency of two variables to be linearly dependent.**,**there are methods to outline non-linear correlations, however we go away them for different articles (however, as data for you: simply think about that they exist).- We’ve mentioned the Easy and the A number of Linear Regression fashions with their assumptions (the assumptions apply to each fashions).
- When speaking about the way to discover the road that most closely fits the information, we’ve referred to the article “Mastering the Art of Regression Analysis: 5 Key Metrics Every Data Scientist Should Know”. Right here, we discover all of the metrics to know to unravel a regression evaluation. So, this can be a generical subject that applies to any regression mannequin, together with the Linear one, after all.
- We’ve proven three strategies to validate our ML fashions: 1)
**The residual evaluation plot**: which applies to Linear Regression fashions, 2)**The precise vs. predicted values plot**: which might be utilized to Linear and Polynomial fashions, 3) the**KDE plot**: this may be utilized to any ML mannequin, even within the case of a classification drawback

Lastly, I need to remind you that we’ve spent a few strains stressing the truth that we will keep away from utilizing `p-values`

to check the hypotheses of our ML fashions. I’m writing an article on this subject very quickly, however, as you may see, the KDE has proven us that our Linear mannequin is nice to unravel this ML drawback, and we haven’t validated our speculation with `p-values`

.

*Thus far on this article, we’ve used some plots. You possibly can **clone this repo** I’ve created with the intention to import the code and use it to simply plot the graphs. When you have some difficulties, you discover examples of usages on my tasks on GitHub. When you have another difficulties, you may **contact me** and I’ll allow you to.*

*Subscribe to**my newsletter**to get extra on Python & Information Science.**Discovered it helpful?**Purchase me a**Ko-fi**.**Preferred the article? Be a part of Medium via**my referral link**: unlock all of the content material on Medium for five$/month (with no extra charge).**Discover/contact me**here**.*