This paper presents a comparative study between Soft Set and K-Nearest Neighbors (KNN) methods for recommendation systems. We utilize the Netflix dataset to analyze and compare the performance of both methods. The Soft Set approach is highlighted as a potentially more effective method due to its flexibility in handling uncertainties and partial truths, as opposed to the more rigid KNN. The results indicate that the Soft Set method provides more accurate and relevant recommendations, showcasing its potential in improving recommendation systems.
In this section, we detail the methodologies employed in our study: the K-Nearest Neighbors (KNN) algorithm and the Soft Set method. Both methodologies are implemented to generate recommendations based on the Netflix dataset, and their performance is compared.
The initial step involves loading and preprocessing the Netflix dataset. The dataset contains information about various titles, including their type, rating, and genres. We start by loading the dataset and removing rows with missing values to ensure data quality. The relevant features for our recommendation system, such as title, type, rating, and genres (listed_in), are then extracted for further analysis. import pandas as pd # Load data d f = pd . r e a d _c s v ( ’ n e t f l i x _ t i t l e s . csv ’ ) # Data c l e a n i n g − remove rows with d f _c l e a n e d = d f . dropna ( ) m i s s i n g v a l u e s # E x t r a c t f e a t u r e s n e e d e d f o r r e c o m m e n d a t i o n s d f _ f e a t u r e s = d f _c l e a n e d [ [ ’ t i t l e ’ , ’ type ’ , ’ r a t i n g ’ , ’ l i s t e d _ i n ’ ] ] . copy ( )
K-Nearest Neighbors (KNN) is a simple yet powerful algorithm used for classification and regression tasks. In our context, KNN is employed to generate movie recommendations. The algorithm works by calculating the similarity between the genres of a given movie and those of other movies in the dataset. The TF-IDF (Term Frequency-Inverse Document Frequency) vectorizer is used to convert the genres into numerical features, and the cosine similarity metric is used to find the k-nearest neighbors. The KNN recommendation function is implemented as follows: from s k l e a r n . f e a t u r e _ e x t r a c t i o n . t e x t import T f i d f V e c t o r i z e r from s k l e a r n . n e i g h b o r s import N e a r e s t N e i g h b o r s # KNN r ecommendation f u n c t i o n def knn_recommendation ( t i t l e , k = 5 ) : t f i d f = T f i d f V e c t o r i z e r ( s t o p _ w o r d s = ’ e n g l i s h ’ ) t f i d f _ m a t r i x = t f i d f . f i t _ t r a n s f o r m ( d f _ f e a t u r e s [ ’ l i s t e d _ i n ’
] ) knn = N e a r e s t N e i g h b o r s ( n _n e i g h b o r s =k + 1 , m e t r i c = ’ c o s i n e ’ ) knn . f i t ( t f i d f _ m a t r i x ) i d x = d f _ f e a t u r e s [ d f _ f e a t u r e s [ ’ t i t l e ’ ] . s t r . c o n t a i n s ( t i t l e , c a s e = F a l s e , regex = F a l s e ) ] . index i f len ( i d x ) == 0 : print ( f " No t i t l e c o n t a i n i n g ’ { t i t l e } ’ found . " ) return [ ] i d x = i d x [ 0 ] d i s t a n c e s , i n d i c e s = knn . k n e i g h b o r s ( t f i d f _ m a t r i x [ i d x ] , n _n e i g h b o r s =k + 1 ) r e c o m m e n d e d _t i t l e s = d f _ f e a t u r e s . i l o c [ i n d i c e s [ 0 ] ] .
t i t l e . v a l u e s [ 1 : ] return r e c o m m e n d e d _t i t l e s 2.3. SoP Set The Soft Set theory provides a mathematical framework for dealing with uncertainties and partial truths. Unlike traditional set theory, Soft Set theory allows for the representation of vague concepts, making it suitable for recommendation systems where user preferences are often imprecise. The Soft Set recommendation function calculates the similarity between the genres of the input title and those of other titles in the dataset using the Jaccard similarity coefficient. This method is more flexible and can handle the partial truths and uncertainties present in the data. The implementation is as follows: # S o f t s e t r ecommendation f u n c t i o n def s o f t _s e t _r e c o m m e n d a t i o n ( t i t l e , t h r e s h o l d = 0 . 6 ) : input_row = d f _ f e a t u r e s [ d f _ f e a t u r e s [ ’ t i t l e ’ ] . s t r . c o n t a i n s ( t i t l e , c a s e = F a l s e , regex = F a l s e ) ] i f input_row . empty : print ( f " No t i t l e c o n t a i n i n g ’ { t i t l e } ’ found . " ) return [ ] i n p u t _g e n r e s = s e t ( [ genre . s t r i p ( ) . lower ( ) for genre in input_row . i l o c [ 0 ] [ ’ l i s t e d _ i n ’ ] . s p l i t ( ’ , ’ ) ] ) g e n r e s _ l i s t = d f _ f e a t u r e s [ ’ l i s t e d _ i n ’ ] . s t r . s p l i t ( ’ , ’ ) . apply
( lambda x : s e t ( [ i . s t r i p ( ) . lower ( ) for i in x ] ) ) def c a l c u l a t e _ s i m i l a r i t y ( g e n r e s ) : return len ( i n p u t _g e n r e s . i n t e r s e c t i o n ( g e n r e s ) ) /
len ( i n p u t _g e n r e s . union ( g e n r e s ) ) d f _ f e a t u r e s [ ’ s i m i l a r i t y ’ ] = g e n r e s _ l i s t .
apply ( c a l c u l a t e _ s i m i l a r i t y )
recommendations = d f _ f e a t u r e s . s o r t _ v a l u e s ( by= ’ s i m i l a r i t
y ’ , a s c e n d i n g = F a l s e ) . head (
To evaluate the performance of the KNN and Soft Set methods, we conducted experiments using the Netflix dataset. We selected the popular TV show "Breaking Bad" as the input title and generated recommendations using both methods. The accuracy of the recommendations was then evaluated based on feature similarity, taking into account the type, rating, and genres of the titles.
The accuracy of the recommendations is assessed by calculating the average similarity of the recommended titles to the input title. The feature similarity is determined by comparing the type, rating, and genres of the titles. The following functions are used to calculate the feature similarity and evaluate the accuracy of the recommendations: # F e a t u r e s i m i l a r i t y c a l c u l a t i o n f u n c t i o n def f e a t u r e _ s i m i l a r i t y ( t i t l e 1 , t i t l e 2 ) : f e a t u r e s 1 = d f _ f e a t u r e s [ d f _ f e a t u r e s [ ’ t i t l e ’ ] . s t r . c o n t a i n s ( t i t l e 1 , c a s e = F a l s e , regex = F a l s e ) ] f e a t u r e s 2 = d f _ f e a t u r e s [ d f _ f e a t u r e s [ ’ t i t l e ’ ] == t i t l e 2 ] i f len ( f e a t u r e s 1 ) == 0 or len ( f e a t u r e s 2 ) == 0 :
return 0 f e a t u r e s 1 = f e a t u r e s 1 . i l o c [ 0 ] f e a t u r e s 2 = f e a t u r e s 2 . i l o c [ 0 ] s i m i l a r i t y = 0 i f f e a t u r e s 1 [ ’ type ’ ] == f e a t u r e s 2 [ ’ type
’ ] : s i m i l a r i t y += 1 i f f e a t u r e s 1 [ ’ r a t i n g ’ ] == f e a t u r e s 2 [ ’ r a t i n
g ’ ] : s i m i l a r i t y += 1 ) g e n r e _ s i m i l a r i t y = len ( g e n r e s 1 . i n t e r s e c t i o n ( g e n r e s 2 ) ) / len
( g e n r e s 1 . union ( g e n r e s 2 ) ) s i m i l a r i t y += g e n r e _ s i m i l a r i t y
return s i m i l a r i t y / 3 # E v a l u a t i o n o f r e commendations a c c u r a c y def e v a l u a t e _r e c o m m e n d a t i o n s _a c c u r a c y ( i n p u t _ t i t l e s , r e c o m m e n d e d _t i t l e s ) : t o t a l _ a c c u r a c y = 0 for i n p u t _ t i t l e in i n p u t _ t i t l e s : i n p u t _a c c u r a c y = 0 r e c o m m e n d e d _t i t l e s _f o r _ i n p u t = r e c o m m e n d e d _t i t l e s . g e t ( i n p u t _ t i t l e , [ ] ) i f len ( r e c o m m e n d e d _t i t l e s _f o r _ i n p u t ) > 0 : for r e c o m m e n d e d _t i t l e in r e c o m m e n d e d _t i t l e s _f o r _ i n p u t : i n p u t _a c c u r a c y += f e a t u r e _ s i m i l a r i t y ( i n p u t _ t i t l e , r e c o m m e n d e d _t i t l e ) i n p u t _a c c u r a c y / = len ( r e c o m m e n d e d _t i t l e s _f o r _ i n p u t ) t o t a l _ a c c u r a c y += i n p u t _a c c u r a c y i f t o t a l _ a c c u r a c y == 0 :
return 0 t o t a l _ a c c u r a c y / = len ( i n p u t _ t i t l e s ) return t o t a l _ a c c u r a c y ∗ 100
We generated recommendations for "Breaking Bad" using both KNN and Soft Set methods. The results were compared to assess the effectiveness of each method in providing relevant recommendations.
The results of our experiments indicate that the Soft Set method outperforms the KNN method in terms of recommendation accuracy. The Soft Set method, with its ability to handle uncertainties and partial truths, provided recommendations that were more similar to the input title "Breaking Bad" in terms of type, rating, and genres. The accuracy of the KNN method was lower, highlighting its limitations in dealing with the imprecise nature of real-world data.
The accuracy of the recommendations is summarized as follows:
Recommendations (KNN)
Recommendations (SoP Sets)
Accuracy (KNN) (%)
In this study, we compared the performance of the K-Nearest Neighbors (KNN) and Soft Set methods for recommendation systems using the Netflix dataset. The dataset was preprocessed to remove missing values, and features such as title, type, rating, and genres were extracted for analysis.
The KNN method was implemented using the TF-IDF vectorizer to convert genre information into numerical features, and cosine similarity was used to find the nearest neighbors. The Soft Set method, on the other hand, calculated the similarity between the genres of the input title and other titles using the Jaccard similarity coefficient.
We evaluated the recommendations generated by both methods using the feature similarity calculation, which took into account the type, rating, and genres of the titles. The accuracy of the recommendations was measured by comparing the average similarity of the recommended titles to the input title.
Our experiments, which focused on the popular TV show "Breaking Bad," demonstrated that the Soft Set method provided more accurate and relevant recommendations compared to the KNN method. Specifically, the Soft Set method achieved higher accuracy by effectively handling the uncertainties and partial truths inherent in user preferences and real-world data.
The results highlight the potential of the Soft Set method as a superior alternative to KNN for recommendation systems. The flexibility of Soft Set theory in dealing with imprecise and incomplete data makes it well-suited for applications where user preferences are not always clear-cut.
Future work could explore integrating Soft Set theory with other machine learning techniques to further enhance the accuracy and effectiveness of recommendation systems. Additionally, expanding the evaluation to include a larger variety of input titles and diverse datasets could provide a more comprehensive assessment of the methods’ performance.