Jio 5G Launch Date in India (Unlimited Data Plans Mobile SIM)

Jio 5G : Reliance Jio 5G & 6G is not long away for its launch in India (5G Launch In India). 5G Mobile SIM Internet is already available in many developed countries in the world and Reliance Jio is planning to introduce it in India with a bang, just like it did for 4G. Reliance Jio 5G Plan details are too early to call, but they are expected to be 15 times more faster than 4G Plans. We may get the full fledged 5G experience around the year 2018. Research groups and companies are testing their proposed 5G equipments and technologies all around the world. Jio 5G Speed test already has proven that there is no stopping for Reliance in Indian Telecommunications Industry. Reliance is expected to become a market leader with the launch of Jio 5G.

Jio 5G Launch in India

Jio 5G Launch Date	Late 2017
Plan Tariff	10X
Speeds	1Gbps-3Gbps
Availability	Prepaid & Postpaid

Jio 5G Speed Test

While testing the 5G Internet speeds, we have seen an impressive and astounding performance. The average download speed has clocked over 2500 mbps (2.5 GB Per Second). Below, we have provided the screen shot of the 5G Speed Test for your reference.

Jio 5G Vs Jio 4G

The major difference from a user point of view between Jio 4G and Jio 5G techniques must be something else than increased peak bit rate. It could be higher number of simultaneously-connected devices, higher system-spectral efficiency (data volume per area unit), lower battery consumption, lower outage probability (better coverage).

Few more differences between Jio 5G and Jio 4G are high bit rates in larger portions of coverage area, lower latencies, higher number of supported devices, lower infrastructure deployment costs, higher versatility and scalability or higher reliability of communications.

5G standards and protocols are still under debate. They are not finalized yet.

Once standards are defined then we need to understand does 5G can be implemented using existing telecom infrastructure like using current BTS (mobile towers) or we need to upgrade technology.

Although 5G standards are still under debate  minimum bandwidth (download speed) could be around 1Gb/sec.

Additional Details on Jio 5G

Jio 5G planning aims at higher capacity than current Jio 4G, allowing a higher density of mobile broadband users, and supporting device-to-device, ultra reliable, and massive machine communications.

Jio 5G is technology which will enable self-driving cars. For a vehicle moving at 100 Kmph it is too long a time, and can get fatal. Jio 5G brings down latency to < 1ms.

Jio 5G is new network system. This technology is better than 4G in downloading speed of 10,000 Mbps, uploading and browsing speed.

Jio 5G will be a flexible and scalable mobile access system based on a new radio interface designed to operate over a wide range of from less than 1 GHz and up to at least 40 GHz that will be deployed on both macro and small cells.

Jio 5G will not be about complicating anything. First and foremost, and before I throw some Jio 5G boilerplate at you, Jio 5G will be about simplifying things and Jio 5G will be about building essential flexibility into a system that is about to be hit by the most diverse set of requirements in any wireless generation.

In Jio 5G, it will no longer be about supporting just a few things. It will literally be about supporting everything – a wireless world that is the “Internet of everything” – as the first generation to target the array of verticals markets that in themselves will define the IoE and its many millions of yet-to-be-imagined applications. That support is the real Jio 5G challenge.

Expectations from Jio 5G

Jio 5g is expected to change the fate of telecommunications in India forever. Analysts already believe that Jio 5G will be one of the most successful ventures in the coming days.

Jio 5G will be made available for much cheaper prices compared to the economics of other countries like USA and Germany.

Another important thing to note about Jio 5G is that, as Reliance has already built the infrastructure that is necessary to build Jio 5G, the penetration is expected to be very high and at record levels in India.

There is also a scope that Reliance will expand its Jio 5G to other countries like Nigeria, England and Malaysia.

Jio 5G Phones will be made available for purchases as soon as SIM Cards are launched. We would like to caution the users before hand that, Jio 5G will not be launched across all parts of India at the same time.

Just like Reliance has launched the Jio 4G services on pilot mode in cities like Mumbai, Pune and Hyderabad, Jio 5G will also be first launched in 15 selected cities.

Based on the feedback from the users and also after making detailed study of other aspects such as Signal Strength, Internet Speeds, Jio 5G Download Speeds and Jio 5G Upload speeds, it will be then launched across all other Indian cities.

Note that FinApp is the first finance portal in India that is providing exclusive information that Jio 5G services and other important details such as Jio 5G launch date etc. All other sites are simply copying our content and are posting as their own content. Readers are expected to take note of the same.

Conclusion : Jio 5G

Most people falsely assume that Jio 5G will be one step ahead of Jio 4G. However, Jio 5G will be 10 times better than Jio 4G.

With Jio 5G, the IoT will no longer be bound to things only; it will become Internet of Everything.

Needless to say, the upcoming Jio 5G technology is estimated to solve the shortcomings of the previous technology and deliver much more that still lies beyond our aspirations.

Storage device

Alternatively referred to as digital storage, storage, storage media, or storage medium, a storage device is any hardware capable of holding information either temporarily or permanently. The picture shows an example of a Drobo, an external secondary storage device.

There are two types of storage devices used with computers: a primary storage device, such as RAM, and a secondary storage device, like a hard drive. Secondary storage can be removable, internal, or external storage.

Examples of computer storage

Magnetic storage devices

Today, magnetic storage is one of the most common types of storage used with computers and is the technology that many computer hard drives use.

• Floppy diskette
• Hard drive
• Magnetic strip
• SuperDisk
• Tape cassette
• Zip diskette

Optical storage devices

Another common storage is optical storage, which uses lasers and lights as its method of reading and writing data.

• Blu-ray disc
• CD-ROM disc
• CD-R and CD-RW disc
• DVD-R, DVD+R, DVD-RW, and DVD+RW disc

Flash memory devices

Flash memory has started to replace magnetic media as it becomes cheaper as it is the more efficient and reliable solution.

• USB flash drive, jump drive, or thumb drive
• Memory card
• Memory stick
• SSD

Online and cloud

Storing data online and in cloud storage is becoming popular as people need to access their data from more than one device.

• Cloud storage
• Network media

Paper storage

Early computers had no method of using any of the above technologies for storing information and had to rely on paper. Today, these forms of storage are rarely used or found. In the picture to the right is an example of a woman entering data to a punch card using a punch card machine.

• OMR
• Punch card

Why is storage needed in a computer?

Without a storage device, a computer can not save or remember any settings or information and would be considered a dumb terminal.

Although a computer can run with no storage device, it would only be able to view information unless it was connected to another one that had storage capabilities.

Why so many different storage devices?

As computers advance so do the requirements for storage space and the technologies used to store data. Because people need more and more space, want it faster, cheaper, and want to take it with them new technologies have to be invented. When new storage devices are designed, as people upgrade to those new devices the older devices are no longer needed and stop being used.

For example, when punch cards were first used in early computers the magnetic media used for floppy disks was not available. After floppy diskettes had been released, they were replaced by CD-ROM drives, which were replaced by DVD drives, which have been replaced by flash drives. The first hard disk drive from IBM cost $50,000, was only 5 MB, was big, and cumbersome. Today, we have smartphones that have hundreds of times the capacity at a much smaller price that we can carry with us in our pocket.

Each advancement of storage devices gives a computer the ability to store more data, save data faster, and access the saved data faster.

What is a storage location?

When saving anything on a computer, it may ask you for a storage location, which is the area in which you would like to save the information. By default, most information is saved to your computer hard drive. If you want to move the information to another computer, save it to a removable storage device such as a flash drive.

What storage devices are used today?

Most of the storage devices mentioned earlier are no longer used with today's computers which primarily use a hard disk drive or SSD to store information and have the options for USB flash drives and access to cloud storage. Desktop computers with disc drives typically use a disc drive that is capable of reading CD's and DVD's and writing CD-R and other recordable discs.

What storage device has the largest capacity?

For most computers, the largest storage device is the hard drive or SSD. However, networked computers may also have access to larger storage with large tape drives, cloud computing, or NAS devices. Below is a list of storage devices from the smallest capacity to the largest capacity.

Note: Many storage devices have been available in many different capacities. For example, over the evolution of the hard drive, there have been drives that range from the first hard drive of 5 MB to hard drives today that are several terabytes in size. Therefore, the below list is only meant to give a general understanding of the size differences between each storage devices today and is not an exact list. For example, the earliest hard drives are smaller than a CD.

1. Punch card
2. Floppy diskette
3. Zip disk
4. CD
5. DVD
6. Blu-ray disc
7. Flash jump drive
8. Hard drive / SSD
9. Tape drive
10. NAS / Cloud Storage

Are storage devices input and output devices?

No. Although these devices do send and receive information, they are not considered an input device or output device. It is more proper to refer to any device capable of storing and reading information from a storage device, disk, disc, or a drive.

Find Domain Name IP Address

https://www.site24x7.com/find-ip-address-of-web-site.html

How to Test Your Eggs for Freshness

Have a carton of eggs with an expiration date that's already passed? Wait! Don't toss them just yet. Even though the use-by date on the side of the egg carton says they've expired, sometimes eggs stay fresh past that date.

Do you know the tried-and-true method to test whether your eggs are still OK to use?

How to Test the Freshness of Eggs

1. Place the egg in a bowl of water.
2. If the egg lays on its side at the bottom, it is still quite fresh.
3. If the egg stands upright on the bottom, it is still fine to eat, but should be eaten very soon, or hard-boiled.
4. If the egg floats to the top, it's past its prime, and not good for eating.

Why this method is accurate

Eggshells are very porous. Over time air passes through the shell into the egg, and its shelf life diminishes as more air enters the shell. Also, the more air that enters the shell, the more buoyant the egg becomes.
Have you ever tried this method for testing the freshness of your eggs? Does it work well for you?

How to check the purity of honey at home?

If you want to enjoy most of the benefits derived from honey. The purity of honey is what you should consider before buying. There are some simple tests and experiments that can be performed at home, to verify the purity of honey. Find out which tests you should try!
Before carrying out any of tests, one basic and extremely simple “how to check the purity of honey” method is to read the label on the jar of honey, prior to its purchase. Manufacturers are required to mention the additives and additional substances that have been added to the produced honey. So you can make out, if it is organic or extra sweet or artificial flavorings have been added, simply by scrutinizing the label. If you are buying honey straight from a beekeeper, then the honey is of a raw and unprocessed quality as you are purchasing it straight from the source.

Conducting tests for purity of honey at home

Honey’s wonderful, delicious variety works against you when you’re trying to find a simple test. Different types of pure honey can cover a large range of density, flammability, and other characteristics. While the following tests are based on true principles, in practice your results may be inconclusive. Try several of these tests to see if the honey fails or passes consistently. In many cases, you can get nothing more than a good guess.

In order to check the purity of honey at home, here’s what to do:

Thumb Test
Here’s the procedure to do a thumb test:

• Put a small drop of the honey you have on your thumb
• Check to see if it spills or spreads around
• If it does, it is not pure
• Pure honey will stay intact on your thumb

How to Implement Random Forest From Scratch in Python

Decision trees can suffer from high variance which makes their results fragile to the specific training data used.
Building multiple models from samples of your training data, called bagging, can reduce this variance, but the trees are highly correlated.
Random Forest is an extension of bagging that in addition to building trees based on multiple samples of your training data, it also constrains the features that can be used to build the trees, forcing trees to be different. This, in turn, can give a lift in performance.
In this tutorial, you will discover how to implement the Random Forest algorithm from scratch in Python.
After completing this tutorial, you will know:

• The difference between bagged decision trees and the random forest algorithm.
• How to construct bagged decision trees with more variance.
• How to apply the random forest algorithm to a predictive modeling problem.

Let’s get started.

• Update Jan/2017: Changed the calculation of fold_size in cross_validation_split() to always be an integer. Fixes issues with Python 3.
• Update Feb/2017: Fixed a bug in build_tree.
• Update Aug/2017: Fixed a bug in Gini calculation, added the missing weighting of group Gini scores by group size (thanks Michael!).

How to Implement Random Forest From Scratch in Python

Description

This section provides a brief introduction to the Random Forest algorithm and the Sonar dataset used in this tutorial.

Random Forest Algorithm

Decision trees involve the greedy selection of the best split point from the dataset at each step.
This algorithm makes decision trees susceptible to high variance if they are not pruned. This high variance can be harnessed and reduced by creating multiple trees with different samples of the training dataset (different views of the problem) and combining their predictions. This approach is called bootstrap aggregation or bagging for short.
A limitation of bagging is that the same greedy algorithm is used to create each tree, meaning that it is likely that the same or very similar split points will be chosen in each tree making the different trees very similar (trees will be correlated). This, in turn, makes their predictions similar, mitigating the variance originally sought.
We can force the decision trees to be different by limiting the features (rows) that the greedy algorithm can evaluate at each split point when creating the tree. This is called the Random Forest algorithm.
Like bagging, multiple samples of the training dataset are taken and a different tree trained on each. The difference is that at each point a split is made in the data and added to the tree, only a fixed subset of attributes can be considered.
For classification problems, the type of problems we will look at in this tutorial, the number of attributes to be considered for the split is limited to the square root of the number of input features.

num_features_for_split = sqrt(total_input_features)

1	num_features_for_split = sqrt(total_input_features)

The result of this one small change are trees that are more different from each other (uncorrelated) resulting predictions that are more diverse and a combined prediction that often has better performance that single tree or bagging alone.

Sonar Dataset

The dataset we will use in this tutorial is the Sonar dataset.
This is a dataset that describes sonar chirp returns bouncing off different surfaces. The 60 input variables are the strength of the returns at different angles. It is a binary classification problem that requires a model to differentiate rocks from metal cylinders. There are 208 observations.
It is a well-understood dataset. All of the variables are continuous and generally in the range of 0 to 1. The output variable is a string “M” for mine and “R” for rock, which will need to be converted to integers 1 and 0.
By predicting the class with the most observations in the dataset (M or mines) the Zero Rule Algorithm can achieve an accuracy of 53%.
You can learn more about this dataset at the UCI Machine Learning repository.
Download the dataset for free and place it in your working directory with the filename sonar.all-data.csv.

Tutorial

This tutorial is broken down into 2 steps.

1. Calculating Splits.
2. Sonar Dataset Case Study.

These steps provide the foundation that you need to implement and apply the Random Forest algorithm to your own predictive modeling problems.

1. Calculating Splits

In a decision tree, split points are chosen by finding the attribute and the value of that attribute that results in the lowest cost.
For classification problems, this cost function is often the Gini index, that calculates the purity of the groups of data created by the split point. A Gini index of 0 is perfect purity where class values are perfectly separated into two groups, in the case of a two-class classification problem.
Finding the best split point in a decision tree involves evaluating the cost of each value in the training dataset for each input variable.
For bagging and random forest, this procedure is executed upon a sample of the training dataset, made with replacement. Sampling with replacement means that the same row may be chosen and added to the sample more than once.
We can update this procedure for Random Forest. Instead of enumerating all values for input attributes in search if the split with the lowest cost, we can create a sample of the input attributes to consider.
This sample of input attributes can be chosen randomly and without replacement, meaning that each input attribute needs only be considered once when looking for the split point with the lowest cost.
Below is a function name get_split() that implements this procedure. It takes a dataset and a fixed number of input features from to evaluate as input arguments, where the dataset may be a sample of the actual training dataset.
The helper function test_split() is used to split the dataset by a candidate split point and gini_index() is used to evaluate the cost of a given split by the groups of rows created.
We can see that a list of features is created by randomly selecting feature indices and adding them to a list (called features), this list of features is then enumerated and specific values in the training dataset evaluated as split points.

# Select the best split point for a dataset def get_split(dataset, n_features): class_values = list(set(row[-1] for row in dataset)) b_index, b_value, b_score, b_groups = 999, 999, 999, None features = list() while len(features) < n_features: index = randrange(len(dataset[0])-1) if index not in features: features.append(index) for index in features: for row in dataset: groups = test_split(index, row[index], dataset) gini = gini_index(groups, class_values) if gini < b_score: b_index, b_value, b_score, b_groups = index, row[index], gini, groups return {'index':b_index, 'value':b_value, 'groups':b_groups}

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# Select the best split point for a dataset def get_split(dataset, n_features): class_values = list(set(row[-1] for row in dataset)) b_index, b_value, b_score, b_groups = 999, 999, 999, None features = list() while len(features) < n_features: index = randrange(len(dataset[0])-1) if index not in features: features.append(index) for index in features: for row in dataset: groups = test_split(index, row[index], dataset) gini = gini_index(groups, class_values) if gini < b_score: b_index, b_value, b_score, b_groups = index, row[index], gini, groups return {'index':b_index, 'value':b_value, 'groups':b_groups}

Now that we know how a decision tree algorithm can be modified for use with the Random Forest algorithm, we can piece this together with an implementation of bagging and apply it to a real-world dataset.

2. Sonar Dataset Case Study

In this section, we will apply the Random Forest algorithm to the Sonar dataset.
The example assumes that a CSV copy of the dataset is in the current working directory with the file name sonar.all-data.csv.
The dataset is first loaded, the string values converted to numeric and the output column is converted from strings to the integer values of 0 and 1. This is achieved with helper functions load_csv(), str_column_to_float() and str_column_to_int() to load and prepare the dataset.
We will use k-fold cross validation to estimate the performance of the learned model on unseen data. This means that we will construct and evaluate k models and estimate the performance as the mean model error. Classification accuracy will be used to evaluate each model. These behaviors are provided in the cross_validation_split(), accuracy_metric() and evaluate_algorithm() helper functions.
We will also use an implementation of the Classification and Regression Trees (CART) algorithm adapted for bagging including the helper functions test_split() to split a dataset into groups, gini_index() to evaluate a split point, our modified get_split() function discussed in the previous step, to_terminal(), split() and build_tree() used to create a single decision tree, predict() to make a prediction with a decision tree, subsample() to make a subsample of the training dataset and bagging_predict() to make a prediction with a list of decision trees.
A new function name random_forest() is developed that first creates a list of decision trees from subsamples of the training dataset and then uses them to make predictions.
As we stated above, the key difference between Random Forest and bagged decision trees is the one small change to the way that trees are created, here in the get_split() function.
The complete example is listed below.

# Random Forest Algorithm on Sonar Dataset from random import seed from random import randrange from csv import reader from math import sqrt # Load a CSV file def load_csv(filename): dataset = list() with open(filename, 'r') as file: csv_reader = reader(file) for row in csv_reader: if not row: continue dataset.append(row) return dataset # Convert string column to float def str_column_to_float(dataset, column): for row in dataset: row[column] = float(row[column].strip()) # Convert string column to integer def str_column_to_int(dataset, column): class_values = [row[column] for row in dataset] unique = set(class_values) lookup = dict() for i, value in enumerate(unique): lookup[value] = i for row in dataset: row[column] = lookup[row[column]] return lookup # Split a dataset into k folds def cross_validation_split(dataset, n_folds): dataset_split = list() dataset_copy = list(dataset) fold_size = int(len(dataset) / n_folds) for i in range(n_folds): fold = list() while len(fold) < fold_size: index = randrange(len(dataset_copy)) fold.append(dataset_copy.pop(index)) dataset_split.append(fold) return dataset_split # Calculate accuracy percentage def accuracy_metric(actual, predicted): correct = 0 for i in range(len(actual)): if actual[i] == predicted[i]: correct += 1 return correct / float(len(actual)) * 100.0 # Evaluate an algorithm using a cross validation split def evaluate_algorithm(dataset, algorithm, n_folds, *args): folds = cross_validation_split(dataset, n_folds) scores = list() for fold in folds: train_set = list(folds) train_set.remove(fold) train_set = sum(train_set, []) test_set = list() for row in fold: row_copy = list(row) test_set.append(row_copy) row_copy[-1] = None predicted = algorithm(train_set, test_set, *args) actual = [row[-1] for row in fold] accuracy = accuracy_metric(actual, predicted) scores.append(accuracy) return scores # Split a dataset based on an attribute and an attribute value def test_split(index, value, dataset): left, right = list(), list() for row in dataset: if row[index] < value: left.append(row) else: right.append(row) return left, right # Calculate the Gini index for a split dataset def gini_index(groups, classes): # count all samples at split point n_instances = float(sum([len(group) for group in groups])) # sum weighted Gini index for each group gini = 0.0 for group in groups: size = float(len(group)) # avoid divide by zero if size == 0: continue score = 0.0 # score the group based on the score for each class for class_val in classes: p = [row[-1] for row in group].count(class_val) / size score += p * p # weight the group score by its relative size gini += (1.0 - score) * (size / n_instances) return gini # Select the best split point for a dataset def get_split(dataset, n_features): class_values = list(set(row[-1] for row in dataset)) b_index, b_value, b_score, b_groups = 999, 999, 999, None features = list() while len(features) < n_features: index = randrange(len(dataset[0])-1) if index not in features: features.append(index) for index in features: for row in dataset: groups = test_split(index, row[index], dataset) gini = gini_index(groups, class_values) if gini < b_score: b_index, b_value, b_score, b_groups = index, row[index], gini, groups return {'index':b_index, 'value':b_value, 'groups':b_groups} # Create a terminal node value def to_terminal(group): outcomes = [row[-1] for row in group] return max(set(outcomes), key=outcomes.count) # Create child splits for a node or make terminal def split(node, max_depth, min_size, n_features, depth): left, right = node['groups'] del(node['groups']) # check for a no split if not left or not right: node['left'] = node['right'] = to_terminal(left + right) return # check for max depth if depth >= max_depth: node['left'], node['right'] = to_terminal(left), to_terminal(right) return # process left child if len(left) <= min_size: node['left'] = to_terminal(left) else: node['left'] = get_split(left, n_features) split(node['left'], max_depth, min_size, n_features, depth+1) # process right child if len(right) <= min_size: node['right'] = to_terminal(right) else: node['right'] = get_split(right, n_features) split(node['right'], max_depth, min_size, n_features, depth+1) # Build a decision tree def build_tree(train, max_depth, min_size, n_features): root = get_split(train, n_features) split(root, max_depth, min_size, n_features, 1) return root # Make a prediction with a decision tree def predict(node, row): if row[node['index']] < node['value']: if isinstance(node['left'], dict): return predict(node['left'], row) else: return node['left'] else: if isinstance(node['right'], dict): return predict(node['right'], row) else: return node['right'] # Create a random subsample from the dataset with replacement def subsample(dataset, ratio): sample = list() n_sample = round(len(dataset) * ratio) while len(sample) < n_sample: index = randrange(len(dataset)) sample.append(dataset[index]) return sample # Make a prediction with a list of bagged trees def bagging_predict(trees, row): predictions = [predict(tree, row) for tree in trees] return max(set(predictions), key=predictions.count) # Random Forest Algorithm def random_forest(train, test, max_depth, min_size, sample_size, n_trees, n_features): trees = list() for i in range(n_trees): sample = subsample(train, sample_size) tree = build_tree(sample, max_depth, min_size, n_features) trees.append(tree) predictions = [bagging_predict(trees, row) for row in test] return(predictions) # Test the random forest algorithm seed(2) # load and prepare data filename = 'sonar.all-data.csv' dataset = load_csv(filename) # convert string attributes to integers for i in range(0, len(dataset[0])-1): str_column_to_float(dataset, i) # convert class column to integers str_column_to_int(dataset, len(dataset[0])-1) # evaluate algorithm n_folds = 5 max_depth = 10 min_size = 1 sample_size = 1.0 n_features = int(sqrt(len(dataset[0])-1)) for n_trees in [1, 5, 10]: scores = evaluate_algorithm(dataset, random_forest, n_folds, max_depth, min_size, sample_size, n_trees, n_features) print('Trees: %d' % n_trees) print('Scores: %s' % scores) print('Mean Accuracy: %.3f%%' % (sum(scores)/float(len(scores))))

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214

# Random Forest Algorithm on Sonar Dataset from random import seed from random import randrange from csv import reader from math import sqrt   # Load a CSV file def load_csv(filename): dataset = list() with open(filename, 'r') as file: csv_reader = reader(file) for row in csv_reader: if not row: continue dataset.append(row) return dataset   # Convert string column to float def str_column_to_float(dataset, column): for row in dataset: row[column] = float(row[column].strip())   # Convert string column to integer def str_column_to_int(dataset, column): class_values = [row[column] for row in dataset] unique = set(class_values) lookup = dict() for i, value in enumerate(unique): lookup[value] = i for row in dataset: row[column] = lookup[row[column]] return lookup   # Split a dataset into k folds def cross_validation_split(dataset, n_folds): dataset_split = list() dataset_copy = list(dataset) fold_size = int(len(dataset) / n_folds) for i in range(n_folds): fold = list() while len(fold) < fold_size: index = randrange(len(dataset_copy)) fold.append(dataset_copy.pop(index)) dataset_split.append(fold) return dataset_split   # Calculate accuracy percentage def accuracy_metric(actual, predicted): correct = 0 for i in range(len(actual)): if actual[i] == predicted[i]: correct += 1 return correct / float(len(actual)) * 100.0   # Evaluate an algorithm using a cross validation split def evaluate_algorithm(dataset, algorithm, n_folds, *args): folds = cross_validation_split(dataset, n_folds) scores = list() for fold in folds: train_set = list(folds) train_set.remove(fold) train_set = sum(train_set, []) test_set = list() for row in fold: row_copy = list(row) test_set.append(row_copy) row_copy[-1] = None predicted = algorithm(train_set, test_set, *args) actual = [row[-1] for row in fold] accuracy = accuracy_metric(actual, predicted) scores.append(accuracy) return scores   # Split a dataset based on an attribute and an attribute value def test_split(index, value, dataset): left, right = list(), list() for row in dataset: if row[index] < value: left.append(row) else: right.append(row) return left, right   # Calculate the Gini index for a split dataset def gini_index(groups, classes): # count all samples at split point n_instances = float(sum([len(group) for group in groups])) # sum weighted Gini index for each group gini = 0.0 for group in groups: size = float(len(group)) # avoid divide by zero if size == 0: continue score = 0.0 # score the group based on the score for each class for class_val in classes: p = [row[-1] for row in group].count(class_val) / size score += p * p # weight the group score by its relative size gini += (1.0 - score) * (size / n_instances) return gini   # Select the best split point for a dataset def get_split(dataset, n_features): class_values = list(set(row[-1] for row in dataset)) b_index, b_value, b_score, b_groups = 999, 999, 999, None features = list() while len(features) < n_features: index = randrange(len(dataset[0])-1) if index not in features: features.append(index) for index in features: for row in dataset: groups = test_split(index, row[index], dataset) gini = gini_index(groups, class_values) if gini < b_score: b_index, b_value, b_score, b_groups = index, row[index], gini, groups return {'index':b_index, 'value':b_value, 'groups':b_groups}   # Create a terminal node value def to_terminal(group): outcomes = [row[-1] for row in group] return max(set(outcomes), key=outcomes.count)   # Create child splits for a node or make terminal def split(node, max_depth, min_size, n_features, depth): left, right = node['groups'] del(node['groups']) # check for a no split if not left or not right: node['left'] = node['right'] = to_terminal(left + right) return # check for max depth if depth >= max_depth: node['left'], node['right'] = to_terminal(left), to_terminal(right) return # process left child if len(left) <= min_size: node['left'] = to_terminal(left) else: node['left'] = get_split(left, n_features) split(node['left'], max_depth, min_size, n_features, depth+1) # process right child if len(right) <= min_size: node['right'] = to_terminal(right) else: node['right'] = get_split(right, n_features) split(node['right'], max_depth, min_size, n_features, depth+1)   # Build a decision tree def build_tree(train, max_depth, min_size, n_features): root = get_split(train, n_features) split(root, max_depth, min_size, n_features, 1) return root   # Make a prediction with a decision tree def predict(node, row): if row[node['index']] < node['value']: if isinstance(node['left'], dict): return predict(node['left'], row) else: return node['left'] else: if isinstance(node['right'], dict): return predict(node['right'], row) else: return node['right']   # Create a random subsample from the dataset with replacement def subsample(dataset, ratio): sample = list() n_sample = round(len(dataset) * ratio) while len(sample) < n_sample: index = randrange(len(dataset)) sample.append(dataset[index]) return sample   # Make a prediction with a list of bagged trees def bagging_predict(trees, row): predictions = [predict(tree, row) for tree in trees] return max(set(predictions), key=predictions.count)   # Random Forest Algorithm def random_forest(train, test, max_depth, min_size, sample_size, n_trees, n_features): trees = list() for i in range(n_trees): sample = subsample(train, sample_size) tree = build_tree(sample, max_depth, min_size, n_features) trees.append(tree) predictions = [bagging_predict(trees, row) for row in test] return(predictions)   # Test the random forest algorithm seed(2) # load and prepare data filename = 'sonar.all-data.csv' dataset = load_csv(filename) # convert string attributes to integers for i in range(0, len(dataset[0])-1): str_column_to_float(dataset, i) # convert class column to integers str_column_to_int(dataset, len(dataset[0])-1) # evaluate algorithm n_folds = 5 max_depth = 10 min_size = 1 sample_size = 1.0 n_features = int(sqrt(len(dataset[0])-1)) for n_trees in [1, 5, 10]: scores = evaluate_algorithm(dataset, random_forest, n_folds, max_depth, min_size, sample_size, n_trees, n_features) print('Trees: %d' % n_trees) print('Scores: %s' % scores) print('Mean Accuracy: %.3f%%' % (sum(scores)/float(len(scores))))

A k value of 5 was used for cross-validation, giving each fold 208/5 = 41.6 or just over 40 records to be evaluated upon each iteration.
Deep trees were constructed with a max depth of 10 and a minimum number of training rows at each node of 1. Samples of the training dataset were created with the same size as the original dataset, which is a default expectation for the Random Forest algorithm.
The number of features considered at each split point was set to sqrt(num_features) or sqrt(60)=7.74 rounded to 7 features.
A suite of 3 different numbers of trees were evaluated for comparison, showing the increasing skill as more trees are added.
Running the example prints the scores for each fold and mean score for each configuration.

Trees: 1 Scores: [56.09756097560976, 63.41463414634146, 60.97560975609756, 58.536585365853654, 73.17073170731707] Mean Accuracy: 62.439% Trees: 5 Scores: [70.73170731707317, 58.536585365853654, 85.36585365853658, 75.60975609756098, 63.41463414634146] Mean Accuracy: 70.732% Trees: 10 Scores: [82.92682926829268, 75.60975609756098, 97.5609756097561, 80.48780487804879, 68.29268292682927] Mean Accuracy: 80.976%

1 2 3 4 5 6 7 8 9 10 11

Trees: 1 Scores: [56.09756097560976, 63.41463414634146, 60.97560975609756, 58.536585365853654, 73.17073170731707] Mean Accuracy: 62.439%   Trees: 5 Scores: [70.73170731707317, 58.536585365853654, 85.36585365853658, 75.60975609756098, 63.41463414634146] Mean Accuracy: 70.732%   Trees: 10 Scores: [82.92682926829268, 75.60975609756098, 97.5609756097561, 80.48780487804879, 68.29268292682927] Mean Accuracy: 80.976%

Extensions

This section lists extensions to this tutorial that you may be interested in exploring.

• Algorithm Tuning. The configuration used in the tutorial was found with a little trial and error but was not optimized. Experiment with larger numbers of trees, different numbers of features and even different tree configurations to improve performance.
• More Problems. Apply the technique to other classification problems and even adapt it for regression with a new cost function and a new method for combining the predictions from trees.

Did you try any of these extensions?
Share your experiences in the comments below.

Review

In this tutorial, you discovered how to implement the Random Forest algorithm from scratch.
Specifically, you learned:

• The difference between Random Forest and Bagged Decision Trees.
• How to update the creation of decision trees to accommodate the Random Forest procedure.
• How to apply the Random Forest algorithm to a real world predictive modeling problem.

Do you have any questions?
Ask your questions in the comments below and I will do my best to answer.

Thanks : Jason Brownlee