DEV Community: Avinash Gupta

Build your own Cryptocurrency !

Avinash Gupta — Sun, 26 Mar 2023 06:13:18 +0000

Hi all, this is Avinash once again with a small blog post. Let's start this blog with a quick question. Have you ever thought of building your own crypto. Look dont lie and don't forget to drop your answer in the comment box. I am asking this because, this idea came to my mind not only once but a lot of times. So, in this post lets do the same. Lets create our own crypto.

So, for building our crypto we will be using ERC20 smart contract. For those who dont know the difference between a Coin and a ERC20 token, read carefully the upcoming content.

Difference between ERC20 Token and a Coin

The main difference between a coin and an ERC20 token is that coins are standalone currencies, whereas ERC20 tokens are created and operate on the Ethereum blockchain.

Coins have their own independent blockchain network and are often designed to serve as a currency or a means of value transfer. Examples of coins include Bitcoin, Litecoin, and Ripple.

On the other hand, ERC20 tokens are created using the Ethereum blockchain and are subject to the rules and protocols of the Ethereum network.

I know you did'nt understand. So, in simple terms coins are those which is built from very scratch. They can have their own blockchain network but on the other hand ERC20 tokens are like set of instructions or we can say a protocol which runs only on the ethereum blockchain in form of a smart contract. There are many ERC20 smart contracts out there in the market. The programer can import it, override it and build his or her own's digital asset.

And this is what we are exactly going to do in this blog post to build our crypto.

Building our Token

As I said there are many ERC20 smart contracts out there in the market. But for this post we gonna use Open Zeppelin. You read it more about it here.

I think I am boring you know. So, lets start the coding aspect of this blog. But if have understood the above concepts you will have some upperhand than others but if you did'nt you can still continue. Code speaks more than the theory - this is what I believe. With this said lets start.

I am calling my token as AviToken. Yeah you got it right it is coming from my name Avinash. And for the smybol I am using AVT, just ethereum use ETH, the same way. You are free to use your name and symbol.

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// This the open zeppelin's ERC20 Tokens smart contract. 
// And this how we import any contract in solidity using import keyword.
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol";


// Its time to override some of the properties of this contract.
// How to do that - simple using 'is' keyword
contract AviToken is ERC20 {

    // creating the constructor so that we can pass our initial supply 
    // of the tokens at the time of deployment.

    // again calling ERC20 contracts constructor to give the name and the symbol of the token
    constructor(uint256 _initialSupply) ERC20("AviToken", "AVT") {

        // upto this everything is correct and this will work absolutely fine. 
        // But next we have to tranfers all of the tokens to the author of this contract 
        // lets do this.

        _mint(msg.sender, _initialSupply);

        // _mint function will help us to do the same
        // basically we are telling to the code that hey just put all of those supply of tokens
        // to the address of the author (msg.sender ---> gives address of the current user)
        // at the time of the constructor calling user will be the author

        // and yes you are done.
    }
}

Try running the above code on the remix ide. It will look something like this.

Deploy it using the ethereum symbol showing in the side bar.

Point to be noted : We will be giving values in WEI i.e 1 = 10^18 Wei

So, lets say if we want to have one million tokens as the intial supply then we have to write it like this : 1000000,000000000000000000

Like this,

Now we have the contract deployed and congratulations to you. You have successfully created your first ever crypto currency.

Now you can interact with this contract. That is you can transfer tokens from one account to another. Using the UI buttons given by the remix ide.

That is for today. Hope you guys enjoyed learning with me. And please drop your comments, questions or anything you want to share below.

Lasso Regression Analysis

Avinash Gupta — Sun, 30 Oct 2022 18:26:29 +0000

What is Lasso regression:

Lasso Regression is a type of linear regression that uses shrinkage. Shrinkage is where data values are shrunk towards a central point, like the mean. The lasso procedure encourages simple, sparse models (i.e. models with fewer parameters). This particular type of regression is well-suited for models showing high levels of multicollinearity or when you want to automate certain parts of model selection, like variable selection/parameter elimination.

The acronym “LASSO” stands for Least Absolute Shrinkage and Selection operator.

L1 Regularization:

Lasso Regression performs L1 regularization, which adds a penalty equal to the absolute value of the magnitude of coefficients. This type of regularization can result in sparse models with few coefficients; Some coefficients can become zero and eliminate from the model. Larger penalties result in coefficient values closer to zero, which is ideal for producing simpler models. On the other hand, L2 regularization (e.g. Ridge regression) doesn’t result in the elimination of coefficients or sparse models. This makes the Lasso far easier to interpret than Ridge.

Performing the Regression:

Lasso solutions are quadratic programming problems, which are best solved with software (like Matlab). The goal of the algorithm is to minimize:

Which is the same as minimizing the sum of squares with constraint Σ |Bj| ≤ s (Σ = summation notation). Some of the βs are shrunk to exactly zero, resulting in a regression model that’s easier to interpret.

A tuning parameter, λ controls the strength of the L1 penalty. λ is basically the amount of shrinkage:

When λ = 0, no parameters are eliminated. The estimate is equal to the one found with linear regression.
As λ increases, more and more coefficients are set to zero and eliminated (theoretically, when λ = ∞, all coefficients are eliminated).
As λ increases, bias increases.
As λ decreases, variance increases.

Code to Explain Lasso Regression Analysis:

import pandas as pd
import numpy as np
import matplotlib.pylab as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LassoLarsCV
from sklearn import preprocessing
from sklearn.metrics import mean_squared_error
pd.options.mode.chained_assignment = None
%matplotlib inline 
RND_STATE = 45123

Loading Data:

data = pd.read_csv("data/tree_addhealth.csv")
data.columns = map(str.upper, data.columns)
data.describe()

Output of Loading Data:

Data Processing:

data_clean = data.dropna()

predvar = data_clean[['BIO_SEX','HISPANIC','WHITE','BLACK','NAMERICAN','ASIAN',
'AGE','ALCEVR1','ALCPROBS1','MAREVER1','COCEVER1','INHEVER1','CIGAVAIL','DEP1',
'ESTEEM1','VIOL1','PASSIST','DEVIANT1','SCHCONN1','EXPEL1','FAMCONCT','PARACTV',
'PARPRES']]

target = data_clean.GPA1

recode = {1:1, 2:0}
data_clean['BIO_SEX'] = data_clean['BIO_SEX'].map(recode)

predictors=predvar.copy()

predictors['BIO_SEX']=preprocessing.scale(predictors['BIO_SEX'].astype('float64'))
predictors['HISPANIC']=preprocessing.scale(predictors['HISPANIC'].astype('float64'))
predictors['WHITE']=preprocessing.scale(predictors['WHITE'].astype('float64'))
predictors['NAMERICAN']=preprocessing.scale(predictors['NAMERICAN'].astype('float64'))
predictors['ASIAN']=preprocessing.scale(predictors['ASIAN'].astype('float64'))
predictors['AGE']=preprocessing.scale(predictors['AGE'].astype('float64'))
predictors['ALCEVR1']=preprocessing.scale(predictors['ALCEVR1'].astype('float64'))
predictors['ALCPROBS1']=preprocessing.scale(predictors['ALCPROBS1'].astype('float64'))
predictors['MAREVER1']=preprocessing.scale(predictors['MAREVER1'].astype('float64'))
predictors['COCEVER1']=preprocessing.scale(predictors['COCEVER1'].astype('float64'))
predictors['INHEVER1']=preprocessing.scale(predictors['INHEVER1'].astype('float64'))
predictors['CIGAVAIL']=preprocessing.scale(predictors['CIGAVAIL'].astype('float64'))
predictors['DEP1']=preprocessing.scale(predictors['DEP1'].astype('float64'))
predictors['ESTEEM1']=preprocessing.scale(predictors['ESTEEM1'].astype('float64'))
predictors['VIOL1']=preprocessing.scale(predictors['VIOL1'].astype('float64'))
predictors['PASSIST']=preprocessing.scale(predictors['PASSIST'].astype('float64'))
predictors['DEVIANT1']=preprocessing.scale(predictors['DEVIANT1'].astype('float64'))
predictors['SCHCONN1']=preprocessing.scale(predictors['SCHCONN1'].astype('float64'))
predictors['EXPEL1']=preprocessing.scale(predictors['EXPEL1'].astype('float64'))
predictors['FAMCONCT']=preprocessing.scale(predictors['FAMCONCT'].astype('float64'))
predictors['PARACTV']=preprocessing.scale(predictors['PARACTV'].astype('float64'))
predictors['PARPRES']=preprocessing.scale(predictors['PARPRES'].astype('float64'))

Making train test split:

pred_train, pred_test, tar_train, tar_test = train_test_split(predictors, target, test_size=.3, random_state=RND_STATE)

Fitting LassoLarsCV

model = LassoLarsCV(cv=10, precompute=False).fit(pred_train,tar_train)

dict(zip(predictors.columns, model.coef_))

m_log_alphas = -np.log10(model.alphas_)
ax = plt.gca()
plt.plot(m_log_alphas, model.coef_path_.T)
plt.axvline(-np.log10(model.alpha_), linestyle='--', color='k',
            label='alpha CV')
plt.ylabel('Regression Coefficients')
plt.xlabel('-log(alpha)')
plt.title('Regression Coefficients Progression for Lasso Paths')

m_log_alphascv = -np.log10(model.cv_alphas_)
plt.figure()
plt.plot(m_log_alphascv, model.mse_path_, ':')
plt.plot(m_log_alphascv, model.mse_path_.mean(axis=-1), 'k',
         label='Average across the folds', linewidth=2)
plt.axvline(-np.log10(model.alpha_), linestyle='--', color='k',
            label='alpha CV')
plt.legend()
plt.xlabel('-log(alpha)')
plt.ylabel('Mean squared error')
plt.title('Mean squared error on each fold')

train_error = mean_squared_error(tar_train, model.predict(pred_train))
test_error = mean_squared_error(tar_test, model.predict(pred_test))
print('training data MSE', train_error)
print('test data MSE', test_error)

training data MSE 0.473352755862 test data MSE 0.462008061824

rsquared_train=model.score(pred_train,tar_train)
rsquared_test=model.score(pred_test,tar_test)
print('training data R-square', rsquared_train)
print('test data R-square', rsquared_test)

training data R-square 0.208850928224 test data R-square 0.204190123696

Cluster Analysis using K-means

Avinash Gupta — Sun, 30 Oct 2022 16:50:07 +0000

Introduction:

The k-means algorithm explores a preplanned number of clusters in an unlabeled multidimensional dataset, it concludes this via an easy interpretation of how an optimized cluster can be expressed.

Primarily the concept would be in two steps:

First, the cluster center is the arithmetic mean (AM) of all the data points associated with the cluster.
Second, each point is adjoint to its cluster center in comparison to other cluster centers. These two interpretations are the foundation of the k-means clustering model.

You can take the center as a data point that outlines the means of the cluster, also it might not possibly be a member of the dataset.

In simple terms, k-means clustering enables us to cluster the data into several groups by detecting the distinct categories of groups in the unlabeled datasets by itself, even without training data.

This is the centroid-based algorithm such that each cluster is connected to a centroid while following the objective to minimize the sum of distances between the data points and their corresponding clusters.

Specifically performing two tasks, the k-means algorithm:

Calculates the correct value of K-center points or centroids by an iterative method.
Assigns every data point to its nearest k-center, and the data points, closer to a particular k-center, make a cluster. Therefore, data points, in each cluster, have some similarities and are far apart from other clusters.

Explanation:

K-Means is just the Expectation-Maximization (EM) algorithm, It is a persuasive algorithm that exhibits a variety of contexts in data science, the E-M approach incorporates two parts in its procedure:

To assume some cluster centers.
Re-run as far as transformed.

E-Steps: To appoint data points to the closest cluster center.
M-Steps: To introduce the cluster centers to the mean.

Where the E-step is the Expectation step, it comprises upgrading forecasts of associating the data point with the respective cluster.
And, M-step is the Maximization step, which includes maximizing some features that specify the region of the cluster centers, for this maximization, is expressed by considering the mean of the data points of each cluster.

In account of some critical possibilities, each reiteration of E-step and M-step algorithms will always yield in terms of improved estimation of clusters’ characteristics.

K-means utilize an iterative procedure to yield its final clustering based on the number of predefined clusters, as per need according to the dataset and represented by the variable K.

For instance, if K is set to 3 (k3), then the dataset would be categorized into 3 clusters if k is equal to 4, then the number of clusters will be 4, and so on.

The fundamental aim is to define k centers, one for each cluster, these centers must be located in a sharp manner because of the various allocation causes different outcomes. So, it would be best to put them as far away as possible from each other.

Also, The maximum number of plausible clusters will be the same as the total number of observations/features present in the dataset.

Code:

from pandas import Series, DataFrame
import pandas as pd
import numpy as np
import matplotlib.pylab as plt
from sklearn.model_selection import train_test_split
from sklearn import preprocessing
from sklearn.cluster import KMeans
from scipy.spatial.distance import cdist
from sklearn.decomposition import PCA
import statsmodels.formula.api as smf
import statsmodels.stats.multicomp as multi 
%matplotlib inline
RND_STATE = 55121

Loading Data:

data = pd.read_csv("data/tree_addhealth.csv")
data.columns = map(str.upper, data.columns)

data_clean = data.dropna()

cluster=data_clean[['ALCEVR1','MAREVER1','ALCPROBS1','DEVIANT1','VIOL1',
'DEP1','ESTEEM1','SCHCONN1','PARACTV', 'PARPRES','FAMCONCT']]

cluster.describe()

Preprocessing Data:

clustervar=cluster.copy()
clustervar['ALCEVR1']=preprocessing.scale(clustervar['ALCEVR1'].astype('float64'))
clustervar['ALCPROBS1']=preprocessing.scale(clustervar['ALCPROBS1'].astype('float64'))
clustervar['MAREVER1']=preprocessing.scale(clustervar['MAREVER1'].astype('float64'))
clustervar['DEP1']=preprocessing.scale(clustervar['DEP1'].astype('float64'))
clustervar['ESTEEM1']=preprocessing.scale(clustervar['ESTEEM1'].astype('float64'))
clustervar['VIOL1']=preprocessing.scale(clustervar['VIOL1'].astype('float64'))
clustervar['DEVIANT1']=preprocessing.scale(clustervar['DEVIANT1'].astype('float64'))
clustervar['FAMCONCT']=preprocessing.scale(clustervar['FAMCONCT'].astype('float64'))
clustervar['SCHCONN1']=preprocessing.scale(clustervar['SCHCONN1'].astype('float64'))
clustervar['PARACTV']=preprocessing.scale(clustervar['PARACTV'].astype('float64'))
clustervar['PARPRES']=preprocessing.scale(clustervar['PARPRES'].astype('float64'))

clus_train, clus_test = train_test_split(clustervar, test_size=0.3, random_state=RND_STATE)

K-means Analysis for 9 clusters:

clusters=range(1,10)
meandist=[]

for k in clusters:
    model=KMeans(n_clusters=k)
    model.fit(clus_train)
    clusassign=model.predict(clus_train)
    meandist.append(sum(np.min(cdist(clus_train, model.cluster_centers_, 'euclidean'), axis=1)) 
    / clus_train.shape[0])

Relation between cluster and average distance:

plt.plot(clusters, meandist)
plt.xlabel('Number of clusters')
plt.ylabel('Average distance')
plt.title('Selecting k with the Elbow Method')
plt.show()

Plotting Output of Relation:

Solution for 3 cluster model:

model3=KMeans(n_clusters=3)
model3.fit(clus_train)
clusassign=model3.predict(clus_train)

pca_2 = PCA(2)
plot_columns = pca_2.fit_transform(clus_train)
plt.scatter(x=plot_columns[:,0], y=plot_columns[:,1], c=model3.labels_,)
plt.xlabel('Canonical variable 1')
plt.ylabel('Canonical variable 2')
plt.title('Scatterplot of Canonical Variables for 3 Clusters')
plt.show()

clus_train.reset_index(level=0, inplace=True)
cluslist=list(clus_train['index'])
labels=list(model3.labels_)
newlist=dict(zip(cluslist, labels))

newclus=DataFrame.from_dict(newlist, orient='index')
newclus.columns = ['cluster']
newclus.describe()

Plotting Clusters:

newclus.reset_index(level=0, inplace=True)
merged_train=pd.merge(clus_train, newclus, on='index')
merged_train.head(n=100)
merged_train.cluster.value_counts()

Output reset_index:

clustergrp = merged_train.groupby('cluster').mean()
print ("Clustering variable means by cluster")
print(clustergrp)

Output of Cluster Variable means:

gpa_data=data_clean['GPA1']
gpa_train, gpa_test = train_test_split(gpa_data, test_size=.3, random_state=RND_STATE)
gpa_train1=pd.DataFrame(gpa_train)
gpa_train1.reset_index(level=0, inplace=True)
merged_train_all=pd.merge(gpa_train1, merged_train, on='index')
sub1 = merged_train_all[['GPA1', 'cluster']].dropna()

gpamod = smf.ols(formula='GPA1 ~ C(cluster)', data=sub1).fit()
print (gpamod.summary())

OLS Regression Results:

print ('means for GPA by cluster')
m1= sub1.groupby('cluster').mean()
print (m1)

print ('standard deviations for GPA by cluster')
m2= sub1.groupby('cluster').std()
print (m2)

mc1 = multi.MultiComparison(sub1['GPA1'], sub1['cluster'])
res1 = mc1.tukeyhsd()
print(res1.summary())

Output for Comparison of means:

A Lasso Regression

Avinash Gupta — Sun, 23 Oct 2022 15:31:47 +0000

Lasso Regression

Lasso regression is a regularization technique. It is used over regression methods for a more accurate prediction. This model uses shrinkage. Shrinkage is where data values are shrunk towards a central point as the mean. The lasso procedure encourages simple, sparse models (i.e. models with fewer parameters). This particular type of regression is well-suited for models showing high levels of multi-collinearity or when you want to automate certain parts of model selection like variable selection/parameter elimination.

The word “LASSO” stands for Least Absolute Shrinkage and Selection Operator. It is a statistical formula for the regularization of data models and feature selection.

Regularization

Regularization is an important concept used to avoid overfitting the data, especially when the trained and test data are much varying. Regularization is implemented by adding a “penalty” term to the best fit derived from the trained data, to achieve a lesser variance with the tested data and also restricts the influence of predictor variables over the output variable by compressing their coefficient. In regularization, what we do is normally keep the same number of features but reduce the magnitude of the coefficients. We can reduce the magnitude of the coefficients by using different types of regression techniques that use regularization to overcome this problem.

Lasso Regularization Technique

There are two main regularization techniques, namely Ridge Regression and Lasso Regression. They both differ in the way they assign a penalty to the coefficients. In this blog, we will try to understand more about Lasso Regularization technique.

L1 Regularization

If a regression model uses the L1 Regularization technique, then it is called Lasso Regression. If it used the L2 regularization technique, it’s called Ridge Regression. We will study more about these in the later sections. L1 regularization adds a penalty that is equal to the absolute value of the magnitude of the coefficient. This regularization type can result in sparse models with few coefficients. Some coefficients might become zero and get eliminated from the model. Larger penalties result in coefficient values that are closer to zero (ideal for producing simpler models). On the other hand, L2 regularization does not result in any elimination of sparse models or coefficients. Thus, Lasso Regression is easier to interpret as compared to the Ridge.
Mathematical equation of Lasso Regression

Residual Sum of Squares + λ * (Sum of the absolute value of the magnitude of coefficients)

Where,

λ denotes the amount of shrinkage.
λ = 0 implies all features are considered and it is equivalent to the linear regression where only the residual sum of squares is considered to build a predictive model
λ = ∞ implies no feature is considered i.e, as λ closes to infinity it eliminates more and more features
The bias increases with an increase in λ
variance increases with a decrease in λ

Example

import numpy as np

Creating a New Train and Validation Datasets

from sklearn.model_selection import train_test_split
data_train, data_val = train_test_split(new_data_train, test_size = 0.2, random_state = 2)

Classifying Predictors and Target

#Classifying Independent and Dependent Features
#_______________________________________________
#Dependent Variable
Y_train = data_train.iloc[:, -1].values
#Independent Variables
X_train = data_train.iloc[:,0 : -1].values
#Independent Variables for Test Set
X_test = data_val.iloc[:,0 : -1].values

Evaluating The Model With RMLSE

def score(y_pred, y_true):
error = np.square(np.log10(y_pred +1) - np.log10(y_true +1)).mean() ** 0.5
score = 1 - error
return score
actual_cost = list(data_val['COST'])
actual_cost = np.asarray(actual_cost)

Building the Lasso Regressor

Lasso Regression

from sklearn.linear_model import Lasso
#Initializing the Lasso Regressor with Normalization Factor as True
lasso_reg = Lasso(normalize=True)
#Fitting the Training data to the Lasso regressor
lasso_reg.fit(X_train,Y_train)
#Predicting for X_test
y_pred_lass =lasso_reg.predict(X_test)
#Printing the Score with RMLSE
print("\n\nLasso SCORE : ", score(y_pred_lass, actual_cost))

Output

    0.7335508027883148

    The Lasso Regression attained an accuracy of 73% with the given Dataset.

Random Forest

Avinash Gupta — Sun, 16 Oct 2022 14:04:51 +0000

About Random Forest Classifier:

Random Forest is a classifier that contains several Decision Trees on various subsets of a given DataSet and takes the average to improve the predictive accuracy of that dataset. During the implementation of homework #2, I fitted several classifiers, including RandomForestClassifier and ExtraTreesClassifier to predict the binary response variable – TREG1 (whether a person is a smoker or not). All variables in the dataset, like age, gender, race, alcohol use, and others (see dataset) were used to build the final model. After fitting the model, these factors influenced the final variable with different levels of importance.
Calculated and sorted descending these factors into feature importance lists:

marever1 0.096374 age 0.083599 DEVIANT1 0.080081 SCHCONN1 0.075221 GPA1 0.074775 DEP1 0.071728 FAMCONCT 0.067389 PARACTV 0.063784 ESTEEM1 0.057945 ALCPROBS1 0.057670 VIOL1 0.048614 ALCEVR1 0.043539 PARPRES 0.039425 WHITE 0.022146 cigavail 0.021671 BLACK 0.018512 BIO_SEX 0.014942 inhever1 0.012832 cocever1 0.012590 PASSIST 0.010221 EXPEL1 0.009777 HISPANIC 0.007991 AMERICAN 0.005332 ASIAN 0.003844

Code:

import pandas as pd
import numpy as np
import matplotlib.pylab as plt
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
%matplotlib inline
RND_STATE = 55324

AH_data = pd.read_csv(“data/tree_addhealth.csv”)
data_clean = AH_data.dropna()
data_clean.dtypes

data_clean.describe()

predictors = data_clean[[‘BIO_SEX’, ‘HISPANIC’, ‘WHITE’, ‘BLACK’, ‘NAMERICAN’, ‘ASIAN’, ‘age’,
‘ALCEVR1’, ‘ALCPROBS1’, ‘marever1’, ‘cocever1’, ‘inhever1’, ‘cigavail’, ‘DEP1’, ‘ESTEEM1’,
‘VIOL1’,
‘PASSIST’, ‘DEVIANT1’, ‘SCHCONN1’, ‘GPA1’, ‘EXPEL1’, ‘FAMCONCT’, ‘PARACTV’, ‘PARPRES’]]

targets = data_clean.TREG1

pred_train, pred_test, tar_train, tar_test = train_test_split(predictors, targets, test_size=.4, random_state=RND_STATE)

print(“Predict train shape: “, pred_train.shape)
print(“Predict test shape: “, pred_test.shape)
print(“Target train shape: “, tar_train.shape)
print(“Target test shape: “, tar_test.shape)

classifier = RandomForestClassifier(n_estimators=25, random_state=RND_STATE)
classifier = classifier.fit(pred_train, tar_train)

predictions = classifier.predict(pred_test)

print(“Confusion matrix:”)
print(confusion_matrix(tar_test, predictions))
print()
print(“Accuracy: “, accuracy_score(tar_test, predictions))

important_features = pd.Series(data=classifier.feature_importances_,index=predictors.columns)
important_features.sort_values(ascending=False,inplace=True)

print(important_features)

model = ExtraTreesClassifier(random_state=RND_STATE)
model.fit(pred_train, tar_train)

print(model.feature_importances_)

trees = range(25)
accuracy = np.zeros(25)
for idx in range(len(trees)):
classifier = RandomForestClassifier(n_estimators=idx + 1, random_state=RND_STATE)
classifier = classifier.fit(pred_train, tar_train)
predictions = classifier.predict(pred_test)
accuracy[idx] = accuracy_score(tar_test, predictions)

plt.cla()
plt.plot(trees, accuracy)
plt.show()

Output:

Final model looked well on test data and showed an accuracy level of 83,4%! So results can be presented in this plot:

As we can see from the plot that even one tree can show the accuracy at a good level. The above-given data can be described even with one tree. But, on the other hand, it is clear, that after adding some more trees final accuracy increases a bit, can make the model able to predict the data more precisely.

CSS Pseudo Elements

Avinash Gupta — Tue, 02 Nov 2021 16:00:58 +0000

Hey friend, are you finding CSS pseudo-elements difficult?
No worries, I was also finding it difficult when I was new to this CSS. In this doc I will be explaining you CSS pseudo-elements in a very easy manner. So lets start,
Suppose I have given you a task to design only the first letter of a word in your HTML page. How will you do this? One will say that okay I will apply a span tag to that letter, and then I will style it. But my friend its 2021 are you thinking that is it a good practice. At the end it's a single word then why will you apply <span> tag.

Right?

Here comes the role of this pseudo-elements. Pseudo-elements is used to customize any specific part of any element.
Till now you have understood that okay a CSS pseudo-element is used to style specified parts of an element. But I you don't know how to do that.
Before jumping into that let me explain you the different types of CSS pseudo-elements present.

There are majorly 6 pseudo-elements available and they are:

::before
::after
::first-letter
::first-line
::marker
::selection

Now, let just discuss them one by one.

::before

p::before{
   content: 'Hello world';
   color: blue;
}

So, before is used to add a content before any class or element. In the above written example Hello world will be embedded before the paragraph with blue color. Now you can customize it according to your choice.

::after
There is no difference in ::before and ::after but as their name suggests before adds content before any element while after will embed it after the element.
::first-letter

p::first-letter{
   color: blue;
}

It is used customize the first letter of any element as we have discussed in the example.

::first-line
Again there is no difference between ::first-line and ::first-letter but as their name is suggesting it is used to customize the first line of any element.
::marker
The marker is used to style the markers of the list item.
::selection
Honestly talking this is my favourite pseudo-element, as it helps to customize the area that has been selected/high-lighted by the user on the dom.
Example speaks: means by default if you high-light any text on the browser the background color changes to blue, but now you customize it by your own. Isn't it amazing. I think you will agree with me.

So, this is was all about the pseudo-elements, hope you liked it and get some new knowledge.
Thank you!

CSS Positions

Avinash Gupta — Sat, 30 Oct 2021 14:22:53 +0000

I am as a beginner faced a lot of difficulty in understanding the Position property in CSS. Today in this doc I will be explaining Positions in a very friendly and easy manner. So, lets begin.

What is position property?
As the name suggest Position is a property in CSS to set the position of an element.
It has 5 values and they are :

static
relative
fixed
absolute
sticky

now again a question arises that is why should we use this is position property?

And the answer is that, after specifying the position property you can use four more properties i.e top, bottom, left and right, which will again help you better to shape your elements to enhance your frontend.

Note: you cannot use these four properties (top, bottom, left, right) directly before specifying the position property. Using them directly without specifying position will be of no use.

Now, we know that what is position property and why should we use it. Now lets quickly jump to those five values and try to better understand them.

static

position: static;

now, static is the default position property, it positions your element according to regular flow of the dom.
(Note: top, bottom, left, and right won't work with static)

Now you know why without defining position property you cannot use top, bottom, left and right. (As if you have not defined the position, the browser will set it to static (default behavior) and top, bottom, left, right won't work with static)

Gist: static is the default behavior of the browser.

relative

position: relative;

relative works relative to the normal position of the element.
I know you didn't understand. Lets take up an example.
Suppose you created a div and set its width and height. Now,

position: relative;
left: 50px;

after applying these two lines in the css of your div, you will find that your div is shifted by 50px from its left. Now this is what means relative to the normal position. Once again, if you apply

top: 100px;

you will see that your div shifted by 100px from its top.
I hope now you get the clear idea.

fixed

position: fixed;

Fixed and relative and totally similar, but the only difference is that the relative position the elements from its normal position while fixed sets the position in relative to the browser window.
Eg.

position: fixed;
left: 5px;

after applying this css your div will move to a distance of 5px from the left of your browser window.
and the important thing is that it won't scroll with your webpage. It will get fixed to that position.

But suppose you want to fix the position with respective to browser window but at same time you want your div to get scroll with your page. How do you do this, as if you will apply position fixed property it won't allow your div to get scroll.

Now, here comes the concept of position: absolute.

absolute

position: absolute;

There are two difference between absolute and fixed.
a. The first one is fixed doesn't allow scroll but absolute does.
b. And the second one is absolute works with the nearest positioned ancestor. Means that fixed sets your element with the respect to the dom window, while absolute sets your div to the nearest ancestor(parent) element who has its position set. But what if there is not parent element with position property, then it will set your according to dom as like fixed but it will still allow scroll.

sticky

position: sticky;

sticky is same is fixed the only difference is it sets the property when ever the element gets out of the window on scrolling.

So, this was all about the position property. Hope you get some knowledge after reading this doc. Thank you.