Java Developer

Project Brief:

INTRODUCTION :

'Supply Chain' mechanism mostly used in PRODUCT transfering. Where the product is created by 'Asset-Creator'and it is transfer to 'the Manufacturer', the 'Manufacturer' transfer the product to the 'Stock Holder' or a 'Ware House' later the 'Stock Holder' transfer the product to 'Wholesaler', from 'Wholesaler' to 'Retailer' and finally 'Retailer' to 'Consumer/Customer'.

PROBLEM-STATEMENT :

The problem here is there is no tracking of product anywhere. In this mechanism we don't know 'how many COUNTER-FEIT (or) FAKE products are added in the network' also don't know 'who are the key players are added these COUNTER-FEIT products'.

SOLUTION :

I have developed this project so that is to 'reduce the adding of the COUNTER-FEIT products in the Supply Chain, so that we can reduce the COUNTER-FEIT of the products in any industry where they have a supply chain mechanism. Make sure that the Customer/End-user will get the 'provenance of the product', means 'the customer can know this product is getting from the original supplied manufacturer or not'. This is because all the data we are keeping on the blockchain. 'ONCE THE DATA IS ON THE BLOCKCHAIN, WE CAN'T MODIFY THE DATA'.

APPROACH :

Supply Chain DApp contains 3 parts, smart contract, Web3 and Frontend. Web3 acts as a middleware between smart contract and frontend. From Web3 we pass '.abi' file (Application Binary Interface). It helps us in communicating the frontend to smart contract and smart contract to frontend.

Here the product has attributes 'name','description' and 'UUID'(Unique User Identification Number). This is unique for every product so we just use this UUID to call the product anywhere in the network.

The 'Asset Creator' will create a product and give name, description and UUID and register on the blockchain.The 'Asset Creator' is the owner of the supply chain, he will transfer the product to the manufacturer and stockholder,etc. But here we are restricting the COUNTER_FEIT products by using 'SMARTCONTRACT'. Every player in the supply chain will definitely have a 'public address' and we can predefine those public addresses so that the product will definitely send 'manufacturer' to the respective public address only. This can be done in every transaction. So finally we are limiting that the product willn't be transfer to any un-authorized person in the supply chain.

Project Brief:

INTRODUCTION :

In real-time we can use 'student registration dapp'. This registration dapp dedicated to school children where we register the student details in a decentalized application.

SCENARIO :

Consider we have a school, here we are taking the consideration of the class 8,9,10 students only, also their percentage of marks and academic scholarship as well as cast scholarship. At the end of the year every student has to know that total fee that will be a pre-defined fee. So keeping into this scenario , by using merit scholarship and caste scholarship we reduce those amount rom the total fee.

APPROACH :

The assigned student detailes can be stored in blockchain. ONCE THE DATA IS ON THE BLOCKCHAIN WE CAN'T MODIFY THE DATA. Every student will have a public address in the blockchain. The student will have name, and public address as the data fields in the smartcontract. We are restricting the students who are registering for the scholarship will close on DEC 31st,2020 (say), also the students which are only belongs to class 8,9,10. Student also have a roolno and no need to save this field on the blockchain because the student roolno may changes year to year, so we are only concern about the public address of the student.

For caste system, I'm restricting if the student is general candidate then give 1, for BC 2, for ST 3 and finally SC 4. If the student is giving caste as a number it will be reflect on the smart contract and will get the caste certificate according to the number. And in schools every student will get maximum of 600 marks.Based on that percentage we have a specific rate and get some amount as scholarship.

Here by clicking on create student, the student details are created on the blockchain and by giving public address of that student we can get the student details name, class, roolno,caste,marks,totalfee . we can also get the total no.of students present in the network.

Project Brief:

WORKING:

Basic Banking application which can transfer money from one account to another account and also show transaction history.

REQUIREMENTS:

1)Start with creating a dummy data in database for upto 10 customers. Database options: Mysql, Mongo, Postgres, etc.

2)Customers table will have basic fields such as name, email, current balance etc. Transfers table will record all transfers happened.

3)Flow: Home Page > View all Customers > Select and View one Customer > Transfer Money > Select customer to transfer to > View all Customers .

4)No Login Page. No User Creation. Only transfer of money between multiple users.

5)Host the website at 000webhost, github.io, heroku app or any other free hosting provider. Check in code in gitHub.

Project Brief:

INTRODUCTION:

Blood Analysis is an essential indicator for many diseases, it has several parameters which are sign for many blood diseases.Depending upon various parameters like age, gender, symptoms and health conditions the physician can choose the specific blood test for diagnosing the disease.Blood tests are widespread because they are helpful in predicting health level of a person. The results of blood reports helps to identify health problems in the early stages.

PROBLEM STATEMENT:

Physicians cannot diagnose diseases and health problems with blood tests alone. However, they can use them as a factor to confirm a diagnosis. These factors may include some signs and symptoms, which could be integrated with other vital signs for diagnosing the diseases and prediction is a necessary process which is based on the quality of data and physicians experience. Sometimes lack of efficiency and experience leads to death.

SOLUTION:

By using Modern Machine Learning (ML) Techniques we can slove this problem. Machine learning is a field responsible for building models for predicting the output based on previous data, it provides systems the ability to automatically learn and improve from experience without being explicitly programmed.We can identify the disease very early using ML.

APPROACH:

In my project, After getting the results If patient have any disease, we build a model that will send message to the patient about their disease.

Firstly,In Machine Learning algorithms accuracy mainly depends on the quality of the dataset,for this reason a high-quality dataset is collected from our college hospital and verified from expert physicians. Train our model by using classical machine learning algorithms. Here I have used basic classifiers i.e; SVM,KNN and Decision Tree and test the model by using real data.Finally the disease can be detected by using these 3 algoritms separately. Among all these algorithms Decision tree is the best Algorithm which gives the best results with better accuracy. So we can directly find the results by using DEcision tree algorithm .After getting the results that results are send to the particular person through a message. So the person can take precautions as early as possible.

MESSAGE SENDING TOOL:

For sending a message I used TWILIO API. Twilio API is a software layer connecting and optimizing communications networks around the world. It is used to send and receive SMS, MMS and OTP messages globally.

Project Brief:

INTRODUCTION:

'Product Recommendation Systems' are used by most of the companies for their products in recent times. As competition increases every organization wants to provide the rich user experience. A 'Product Recommendation System' is a software tool designed to generate and provide suggestions for items or content a specific user would like to purchase or engage with. Utilizing machine learning techniques and various data about both individual products and individual users, the system creates an advanced net of complex connections between those products and those people

There are three basic types of connection a product recommendation system creates:

1. User-product relationships – based on user's individual product preferences.

2. User-user relationships – based on similar people (i.e. people of a similar age, background, etc.) likely having similar product preferences.

3. Product-product relationships – based on similar or complementary products (e.g. printers and ink cartridges) that can be categorised into relevant groups.

Product recommendation systems compare and rank these connections, and recommend products or content accordingly.

IMPLEMENTATION:

In order to build a product recommendation system, the first thing that’s needed is data.The more data collected the better. In our project we have collected data from the GOOGLE Data Corpus. Actually it is a huge data corpus, our dataset contains 19 features and it will be stored in a PICKEL file.

Once the data has been collected and stored,we are performing data-cleaning operations on that data for cleaning purpose. Titles are considered for product similarity for the text based analysis. We create d-dimensional vector for every title given in the document corpus. For the given input title, we calculate Euclidean distance with all other titles in the corpus. The less Euclidean distance values are the more similar products.

We used 'Text based Product Similarity' by calculating 'Inverse Document Frequency', By using 'Text based Similarity' we cannot achieve semantic(meaning) relationship between words. It only concentrates on textual behaviour. For that we have also used 'Semantic based Product Similarity', by using 'IDF-WEIGHTED-W2V-VISUAL based product similarity' We compute the Euclidean distance between the average-word-to-vec of given title to the Average-word-to-vec of all the remaining titles in the data corpus. The products which are having lower ecludian distance are said to be similar products and that will be recommended to the particular user.

Project Brief:

SOLVER:

First the program scans each cell and if there exists only one possibility, then it inserts that number. The program does this until the puzzle is stuck. Then it runs a backtracking DFS search to "try out" the possibilities, eliminating those (and its children) that doesn't work.

I aimed for code readability and simplicity over running time, although this program can solve a Sudoku puzzle in ~0.2s on average (Note that solving Sudoku puzzles is NP-complete).

GENERATOR:

The generator starts with an empty 9x9 grid and fills it up by iterating from the top left cell to the bottom right, and filling in the cells by trying random numbers. It checks if the inserted number works, and if so, continue on recursively. Then the full 9x9 grid is reduced down so that it becomes the start of a Sudoku puzzle. It generates a list of integers 0-80 representing the indices in the puzzle, then scrambles the order. To reduce, we try to remove the number at the first index in the list and then attempting to solve the puzzle.

If there exists more than one solution, then it is not a valid Sudoku puzzle, so undo the last change. If easy puzzles are desired, then after a puzzle with a unique solution is found, algorithm stops. If difficult puzzles are wanted, then even after a valid puzzle is found, all the remaining indices are tried to see if the puzzle can be made any harder. The difficult puzzles are not only unique boards, but boards where you cannot remove any more numbers without destroying the uniqueness of the solution.

HOW TO RUN:

To run the generator:

python Generator.py

To run the solver:

python pySudoku.py Sudokus.txt

Ofcourse, you can use the solver with any text file that contains Sudoku puzzles. The generator writes to a file named "SudokuPuzzles.txt", with each puzzle being represented as one line of integers read from the top left to the bottom right of the grid.

Project Brief:

INTRODUCTION:

Self Driving Car is one of the most disruptive innovations in AI. Fuelled by Deep Learning algorithms, they are continuously driving our society forward and creating new opportunities in the mobility sector. An autonomous car can go anywhere a traditional car can go and does everything that an experienced human driver does. But it’s very essential to train it properly. One of the many steps involved during the training of an autonomous driving car is lane detection, which is the preliminary step.Self Driving cars use lane detection OpenCV features to detect lane of the roads. They are trained not to drive out of the lanes.

APPROACH & IMPLEMENTATION:

Lane detection involves the following steps:

1)Capturing and decoding video file

2)Grayscale conversion of image

3)Reduce noise

4)Canny Edge Detector

5)Region of Interest

6)Hough Line Transform

1)Capturing and decoding video file:

We will capture the video using Video Capture object and after the capturing has been initialized every video frame is decoded (i.e. converting into a sequence of images). Video is nothing but sequence of images.

2)Grayscale conversion of image:

The video frames in OpenCV are in BGR format converted to grayscale because processing a single channel image is faster than processing a three-channel colored image.

3)Reduce noise:

Noise can create false edges, therefore before going further, it’s imperative to perform image smoothening. Gaussian filter is used to perform this process.

4)Canny Edge Detector:

It computes gradient in all directions of our blurred image and traces the edges with large changes in intensity.

5)Region of Interest:

This step is to take into account only the region covered by the road lane. It mask out everything else except the portion which is being defined by the triangle .

6)Hough Line Transform:

Using probabilistic Hough lines, we identify the location of lane lines on the road. The Hough transform algorithm extracts all the lines passing through each of our edge points and group them by similarity. The HoughLinesP function in OpenCV returns an array of lines organized by endpoints (x1, x1, x2, x2). It’s important to understand that we are no longer viewing point in the (x, y) cartesian coordinate system but are now viewing points in the (ρ, θ) polar coordinate system that the Hough transform operates in. Understanding the internals of this transform helps manipulating parameters provided to the function.

SORT LINES:

The Hough transformation gives us back multiple lines, but we only want two distinct lanes for our car to drive in between. We have two distinct sets we want to detect: the left and the right lane markers. In this section, we organize lines by slope.Positive slopes are for the right lane and negative slopes are for the left lane.

REJECT OUTLIERS:

We then filter out lines with unacceptable slopes that throw off the intended slope of each line.

RUN LINEAR REGRESSION:

We finally merge left and right sets using linear regression. Linear regression is an attempt at finding the best relationship between a group of points. We are getting a line that passes at the closest possible distance from each point. We apply linear regression on both the left and right sets of lines.

SPAN LINES:

Using some simple geometry (y = mx + b), we calculate extrema. We use the result of the linear regression to extrapolate to those extrema. We extend the left and right lines off across the image and clip the line using our previous region of interest.

Draw the lines and return the final image:

The final step is to superimpose the left and right lines onto the original image to visually validate the correctness and accuracy of our pipeline implementation using a weighted computation for each pixel.

We have developed and implemented an algorithm for detecting lanes on the road. The lane detection method is robust and effective in finding the exact lanes by using both color and edge orientations. The main contributions are the color segmentation procedure identifying the colored lanes followed by edge orientation in which the boundaries are eliminated, lanes are detected, left and right regions are labeled, outliers are removed and finally one line per region remains after using a linear regression on each set.

As the camera remains constant with respect to the road surface, the road portion of the image can be exclusively cropped by providing coordinates, so that identifying the lanes becomes much more efficient. The experimental results show the effectiveness of the proposed method in cases of lanes. The entire work is done in a static way using static images and extended to detect lanes in videos.

Project Brief:

REQUIREMENTS:

DESCRIPTION:

Build Sample spring boot application with below use cases.

users information -> id, fname, lname, email, designation,ph num, address,activeuser

address -> id, hno,streetname,pincode, state, districts

Build below list of APIs

1) save user information

2) update user information

3) retrieve user by any email

4) retrieve list of users whose designation is same

5) retrieve list of active users

6) integrate this microservice with gateway

7) Junit5 test cases for each case.

FORMAT :

Should be able to run the APIs through postman and get the expected response.