Movie recommendation and classification system using block chain

3.1. Blockchain based collaborative filtering RS implementation

All transactions on the decentralized network known as Blockchain take place between peers. By integrating blockchain technology with RS, consumers can accept recommendations without a central authority’s approval. The collaborative filtering method based on blockchains is a practical approach to actualize the RS. Assume that the rank-utility matrix R provided by users U and T serves as the algorithm’s fundamental information. To create user portraits, decompose the R matrix.

Collaborative filtering using Blockchain

________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

Method: Gather user movie ratings

User: Encrypt movie ratings r i j → Enc ( r i j )

Send user and Enc ( r i j ) to the RS → Erj ( r i j )

RS: mask rating Enc ( r i j )

Send the rating (masked) Enc ( r i j ) to the Collaborative System

Method: Matrix factorisation Erj ( r i j )

Decrypt Collaborative Filtering Systems → Erj ( r i j )

Set the dimension vector and calculate encryption

Send the encrypted data to the RS

Update the matrix (rating) factorisation data.

Verify and Update the stopping criteria

OPEN IN VIEWER

Fig. 1.

Collaborative system using blockchain network.

Blockchain-based collaborative filtering methods first use a collaborative filtering system to collect data and encrypt individual users’ ratings or factors (see Fig. 1). The encrypted user categories are then sent to the recommendation system, which generates a random mask for each data category. The random mask data is encrypted and returned to the collaborative network. During the next phase (matrix factorization), the collaborative network decodes the masked evaluation information and creates dimension vectors for the data. This information is again encrypted and sent back to the recommendation system. The RS encrypts the amplitude vector data and eliminates the corresponding mask vectors to get a final data estimation. Repeat the sorting process until the stopping criterion is reached.

To address the drawbacks of current recommendation systems, we develop a collaborative filter recommendation algorithm in this article that uses blockchain technology. Using collaborative filtering, recommendations are made based on matches between similar interests. The similarity matrix method is used to determine an item’s recommendation score. The closer a user’s relationship with another user, as determined by the similarity approach, the larger the impact on the recommendation score. A straightforward method of collaborative filtering is shown in Fig. 2. User P1 and User P2 rate movies according to their interests, as evidenced. A matrix of user movies is created based on this, and a comparative model is used to detect commonalities between movies and suggest them to other users [1].

Blockchain technology and a collaborative filtering technique create a movie recommendation system. The overall scheme of the projected technique is shown in Fig. 3. In this scheme, the Blockchain keeps records of transactions unrelated to governments or institutions. A blockchain’s peer-to-peer architecture acts as a distributed ledger for all transactions. Members can utilize this knowledge to support dealings or proposals without a chief certification authority (CA). In a collaborative recommender system, Blockchain is used to perform computations in the recommender system without exposing any inputs.

OPEN IN VIEWER

Fig. 2.

Collaborative filtering method example.

We use the Flask microframework to create termination points for several blockchain technology functions and analyze data on multiple computers to produce a decentralized system. A simple blockchain-connected user interface stores data and recommends movies based on user rating information. Here, the main goal is to develop a plan which authorizes users to share and post data. Because data is stored in the Blockchain, it is unassailable and everlasting. It permits users to use an APP via a simple website interface and obtain movie recommendations.

A simulated RS video is created in the planned research using a machine learning technique. After that, RS – related privacy issues are solved by a simple Ethereum-based blockchain. A decentralized network is created using Flask microframework, which interacts with Blockchain to store information and give proper endorsements based on user assessments for an agreed movie title.

The main aim is to form a system where users can share data through publishing. Data is kept on the Blockchain, so it is permanent and unassailable. Users use the app via a simple interface (web) and obtain recommended movies. Initially, we decided to store our data structures on the Blockchain. Herein, three main essentials identify messages sent by all users of the application:

In the next section, we describe a proof-of-concept of our proposed method.

A complete process of collecting relevant information and an algorithmic approach for the recommendation system is shown in Fig. 4.

OPEN IN VIEWER

Fig. 3.

Blockchain for movie recommendation system. Here, the users recommend the movies, node servers perform dual communication (input/output) and communicate with Blockchain network. Blockchain is used to perform computations in the recommender system using decentralized system without exposing any inputs.

OPEN IN VIEWER

Fig. 4.

Demonstration of proof-of-work algorithm method used in movie recommendation system. The whole process is computed in 5 steps (explained detail in the paper) which include: i) User movie input, ii) user inputs connect to the node server, iii) movielens database interaction, iv) new blocks addition to blockchain and v) movie recommendation.

In this process, the personalized movie input data and the movie information of each data set are compared, and the similarity index between them is computed using the “cosine similarity method.” Here, we count the number of slices after comparison and close the process. The group chooses the total number of movies in a group, with the most 1 being the most shared group for each movie. Finally, the top 10 movies from the list are recommended to the user. Users can also select a movie to watch from their recommended movies.

We describe the proposed movielens algorithm (pseudo code) here:

Input: movie_training.csv

Output: Movie recommendation

Generate block of movie data

 For each block (hash 256), add fingerprint

 Link each block

 Include information collection block

 Initialize movie array, consensus

  For i=1 for movie array do

   For movie array j=1 do {

   start movie node

    For m=2 to 800

    as movie matrix[i,m] == moviematrix[j,m]

    movie_node_a[m] =1

    else

    movie_node_a[m] = 0

  end

   end

    end

Form Interfaces for every movie

Check Result

OPEN IN VIEWER

Fig. 5.

The planned movie recommendation scheme using collaborative filtering (example).

The proposed approach describes a mathematically relevant algorithmic roadmap for movie recommendation. We experimented with this technique to find a good fit with the film. As part of this work, a set of the most suitable films was developed, and recommendations for these tests were calculated. First, we test using a list of at least 20 movies compared to a dataset containing randomly selected movies from different movie attributes. In this case, when m = 0, 800 films are recommended to the user. The number of movies rated 3.5 is used to create a path that divides the movies in the original dataset into groups of 7, 8.7, and 10 in random order. We also designed another test on the same dataset, where movies were randomly assigned with different characteristics and rated at least 10, 20, and 50 movies consecutively. It then recommends movies to the user by sequentially noting the number of movies as 3, 5, 7, 8, 7, and 10. Calculate the accuracy rate, run 150 times, and take the average as the accuracy rate value.

The proposed movie recommender system is rated using the accuracy of the forecasting technique. The Mean Absolute Error Percentage (MAPE) is used to evaluate the proposed approach [2,40,42]. (1) MAPE = 100 % n ∑ t n A t − F t A t

Equation (1) represents the forecast and actual values as F t and A t , respectively. Performance was evaluated by equating the MAPE value to collaborative filtering using the “k- nearest neighbors” method. If the results are aggregated, and the number of recommended results is low, we state that our planned action is restored. Here, we use equation (1) to find performance reliability and get better prediction accuracy by running the movie recommendation test 10 times. Then, we discuss how to implement it.

OPEN IN VIEWER

Fig. 6.

Flowchart of the Blockchain-based movielens recommender system.

4.1. Store connections into blocks

We stored information on the Blockchain in the popular JSON format. Messages stored on the Blockchain include:

The common phrase “data” is often replaced on the Internet by the term “transaction.” Therefore, to avoid confusion and for consistency, “transactions” refer to the data placed in the sample application. Transactions are reduced hooked on blocks. A block can comprise more than one transaction. Blocks containing contracts are usually created and added to the Blockchain. Each block must have a unique ID since there can be multiple blocks, as shown below:

Class block implementation

Class block:

Initialization, index, transaction, and timestamp.

4.2. Blockchain includes digital information

We used the power of cryptographic hashing to detect forged data in blocks. “A hash function is a job that receipts information of any length and harvests a fixed-size data (called a hash) used to identify the input.” Features of a perfect hash function include:

If the input and the hash are known, the input can be passed through a hash function to authenticate the delivered hash. This irregularity between the amount of work required to compute the hash of the input (easy) and the effort needed to compute the hash of the input is what blockchains use to achieve the chosen properties

From the hash library, import sha256 and json

We have stored the block hash in an area of the block object, which acts as a digital fingerprint (or signature) of the data it contains. In most cryptocurrencies, individual transactions are stored in a block and hashed in an arrangement of Merkle trees (we can also call them hash trees). The block hash is also called the root of the tree. Blockchain is unnecessary for the job, so I didn’t mention it to keep it short and simple.

4.3. Chain the blocks

The next step is to install the blocks. A blockchain is a set of blocks. You can store all chunks in Python (like an array). However, this process alone is not enough. What happens if someone deliberately changes an old block in a group with a new one? In the current implementation, it is not a problem to create a new block containing the modified transactions, calculate the hash, and replace it with the old block.

We require a technique that ensures modifications to earlier blocks will invalidate the entire chain. By fusing subsequent blocks’ hashes with the prior block’s, Bitcoin establishes dependencies. Chaining entails writing the previous hash from the block into the current block’s new previous hash field. What happens to the first block if each block includes a hash prior field connecting it to the previous block? The genesis block is the first and can be made manually or using some logic. Building our initial blockchain composition is as simple as adding the previous_hash to our new block (see Listing 1).

When the previous block’s content changes, the last block’s hash also changes. This causes a disparity with the former hash in the following block. When the input to calculate the hash function for a particular block includes the previous_hash field, the hash value for the next block is also changed. Eventually, the entire string following the replacement block becomes invalid, and the only way to fix this is to recompute the whole string.

4.4. Proof of work algorithm

Any changes to the previous block can quickly recalculate the next block’s hash and create another valid blockchain. To avoid this, we use the asymmetry of hash functions discussed earlier to compute complex random hashes. That’s it. It adds

Add the previous block (hash) to chain to which this block belongs.

some restrictions as an alternative to accepting (block) hashes. Let’s include a constraint that the hash must start with a leading zero. “The value of n here can be any positive value, and n can be any integer (positive number).”

We know that the hash value only changes when the data in

Define proof_of_work(self, block):

the block changes. We do not intend to alter the current information. That is why we add dummy data that can be edited. So, we introduced new data in the block named “nonce.” The nonce is the number to modify until a hash satisfying the constraint is obtained. A random number that meets the constraints proves that a particular calculation was performed. A zero limit specifies the “complexity” and consistency of the verification algorithm. Proof of work is also problematic to compute due to asymmetry but is easy to verify once the nonce has been identified (requiring a restart of the hash function).

We can confirm that there is no reason to determine the nonce swiftly. However, it is just automatic strength. The only improvement we could provide is hardware changes projected to calculate hash functions with fewer CPU instructions.

4.5. Include Blockchain

Adding a block to the chain requires ensuring that the information has not been altered, i.e., the proof-of-concept given is accurate and the transaction order is preserved, i.e., the added block’s preceding_hash arena checks to its hash. This is the final block in the chain. Now, we can investigate the code below:

“Blockchain class:

Continuation of the previous code.

1) Add_block(self, block, proof) definition:

A function to add a block to the chain after authentication.

Validation consists of:

* Validation of credentials.

* The preceding_hash assigned to the block is the same as the last block hash assigned to the chain.

return False

 if not Blockchain.is_valid_proof (block, proof):

    return False”

 “2) preceding-hash = self.final-block.hash

  Definition if preceding-hash!=

   block. preceding-hash:

    returns Incorrect

    if not a blockchain.

  is_legal-proof(block, proof):

    return Incorrect”

 “3) set block.hash = proof

    self.chain.add(block)

     return Correct

    definition is_valid_proof

    (self, block, block_hash)

 4) check if block_hash is valid it is a block hash that meets the

    complexity criterion.

      """ returns

      (block_hash.

    startwith(‘0’ * Blockchain.difficulty) è

    block_hash == block.compute_hash())” Block hash – Blockchain connection

4.6. Data mining

Initially, operations are deposited as a pool of uncommitted contracts. Block mining is placing unconfirmed transactions into blocks and computing proof of work. If the nonce satisfies the constraints, we can confirm that the block was mined and uploaded to the chain. In most cryptocurrencies (including Bitcoin), miners can be paid in certain cryptocurrencies in exchange for using their computing power for proof-of-work payments.

4.7. Generate interfaces

We establish interfaces for the blockchain nodes to intermingle with the applications we intend to build. We used a famous Flask, a Python network, to set up a “REST API” to run and interact with numerous procedures on blockchain nodes. Applications require endpoints to send new transactions and are used by applications to include novel information (messages) to the Blockchain. Here is the endpoint for returning a replica of the chain nodes. Our method uses this endpoint to request all information to be displayed. A termination point that asks the node to mine unsubstantiated operations (if any): Use this to run mining commands from the application itself. These REST endpoints could be utilized with the Blockchain by creating and retrieving some transactions.

4.8. Establish consensus and decentralization

Our blockchain implementation is designed to use minimum computer hardware space and hence can run on a single computer. Even if you associate a block with a hash and apply sanity check restrictions, you still cannot trust a single entity (a single system in this case). Deployments require data. Multiple nodes are required to maintain a blockchain. In this way, other peers in the network are notified of the transition from one node to the new one.

However, multiple nodes can experience issues due to intentional actions or unintended details such as network latency. In this case, the nodes must agree on a specific string form to maintain the whole schema’s authenticity. This means that we must reach a “consensus.” When the strings of participating nodes in the network seem to differ, a simple agreement procedure can agree on the longest valid string. The logic behind this technique is that the longest chain reasonably estimates most of the work done.

Now, we need to find a way for all nodes to tell the network that Block A exists. Anyone can then update the blockchain and mine other transactions. Other nodes can verify proof of work and add mined blocks to the chain. The announce_new_block method should be called after a node has fetched each block so that peers can add the block to the chain.

4.9. Integrate the recommendation code in the Blockchain

Now that the blockchain server is configured. The next step is to begin operating on the API. We use Jinja2 templates to execute our web pages and some CSS to make everything appear suitable. We need to connect our application nodes in the blockchain network to receive and transmit new information. There can be several nodes of this type.

“import date and time, import json and import request

4.10. Build the application

After running all the previous functions, run the final script in the views.py file to run the final application.

“Determine the operating system and initialize the project application.

q=mp.Queue()

p=mp.Process(target=foo)

p.start()

os.system("python3 Project.py")”

5.1. Evaluation of the proposed method

The Blockchain allows users to update existing models hosted by user groups or individuals by sharing information such as model parameters and new movie titles. When adding movie rating data, the reward mechanism requires confirmation. Our technique allows users to verify the system’s accurateness by submitting data. The proposed method captures the movement of each calibrated film. The model absorbs to commend suitable movies to users by computing the “similarity matrix between users.” Also, the same user cannot re-rate previously viewed movies. First, users rate movies in various genres, such as melodrama, action, drama, and comedy. The system then automatically provides user rating predictions for specific movies that have not yet been rated.

Next, we explain and evaluate the proposed method briefly. We store the Metadata for all movie recommendations in a specific file, “python_blockchain_app-master/app/metdata.csv” After running the code, we get the following HTML version (Refer to Fig. 7).

OPEN IN VIEWER

Fig. 7.

Enter the movie name in the text box: click on request to block recommended movies button.

After entering a sample movie title, the user node will be blocked by using a new tab. Then return to the first tab that displays the Recommendations page (see Fig. 8).

OPEN IN VIEWER

Fig. 8.

First tab with recommendation page.

User details can be found here by clicking the “Time Stamped User Details tab.” It is nothing more or less than a resynchronization of the Blockchain of updated information.

Run the movie recommendation code based on user preferences and recommend movies button (see Fig. 9). Here, we recommend that users use the collaborative filtering model. The complete output of the Python script is available (saved) in the file “python_blockchain_app-master/app/Output.html.”

OPEN IN VIEWER

Fig. 9.

Movie recommendation based on user preferences.

The user can get the results (Fig. 10) by clicking the “Movie Recommendations based on the user Preferences button.”

OPEN IN VIEWER

Fig. 10.

Complete result of the proposed blockchain application.

Using an actual dataset, we evaluated the performance of the proposed recommendation system. Acceptable recommendation models are based on filtering together users, items, and random data. For analysis purposes, we used the Movielens 100,000 Dataset, which contains 100,000 movie reviews from 943 users for 1,682 movies released in April 1998. Here, users have evaluated, in any case, 20 movies. The data source can be found at the following website link: https://grouplens.org/datasets/movielens/100k/.

An example of the movie RS rating of the users is shown in Table 2. Similarly, an example of movie Recommendation scores is given in Table 3. Using Table 2 and Table 3, we compute the overall movie recommendations.

For example, for User 3, the overall movie recommendation is calculated based on the two table elements (Table 4).

Different collaborative filtering models were selected to govern the best algorithm. Here we report the outcomes of “Movielens”, collected as a blockchain launch prioritizing movies all users recommend. We included a user ID from 1 to 10, a movie ID from 1 to 200 and a rating matrix from 1 to 5. Table 5 shows the derived Blockchain showing users (highest priority) and recommended movies.