Web3Recommend

app/src/main/AndroidManifest.xml

@@ -191,6 +191,11 @@
             android:enabled="true"
             android:exported="false" />
 
+        <service
+                android:name="nl.tudelft.trustchain.musicdao.core.recommender.gossip.EdgeGossiperService"
+                android:enabled="true"
+                android:exported="false" />
+
         <meta-data
             android:name="com.google.android.geo.API_KEY"
             android:value="AIzaSyBAGd8-KwX1epS_0CPl5RF0hD8VeTmM-7Y" />

app/src/main/java/nl/tudelft/trustchain/app/TrustChainApplication.kt

@@ -68,6 +68,7 @@ import nl.tudelft.trustchain.eurotoken.db.TrustStore
 import nl.tudelft.trustchain.gossipML.RecommenderCommunity
 import nl.tudelft.trustchain.gossipML.db.RecommenderStore
 import nl.tudelft.trustchain.literaturedao.ipv8.LiteratureCommunity
+import nl.tudelft.trustchain.musicdao.core.ipv8.TrustedRecommenderCommunity
 import nl.tudelft.trustchain.peerchat.community.PeerChatCommunity
 import nl.tudelft.trustchain.peerchat.db.PeerChatStore
 import nl.tudelft.trustchain.valuetransfer.community.IdentityCommunity
@@ -119,7 +120,8 @@ class TrustChainApplication : Application() {
                 createRecommenderCommunity(),
                 createIdentityCommunity(),
                 createFOCCommunity(),
-                createDeToksCommunity()
+                createDeToksCommunity(),
+                createTrustedRecommenderCommunity()
             ),
             walkerInterval = 5.0
         )
@@ -457,6 +459,14 @@ class TrustChainApplication : Application() {
         )
     }
 
+    private fun createTrustedRecommenderCommunity(): OverlayConfiguration<TrustedRecommenderCommunity> {
+        val randomWalk = RandomWalk.Factory()
+        return OverlayConfiguration(
+            TrustedRecommenderCommunity.Factory(this),
+            listOf(randomWalk)
+        )
+    }
+
     private fun getIdAlgorithmKey(idFormat: String): BonehPrivateKey {
         val prefs = PreferenceManager.getDefaultSharedPreferences(this)
         val privateKey = prefs.getString(idFormat, null)

freedomOfComputing/src/main/java/nl/tudelft/trustchain/FOC/community/FOCCommunity.kt

@@ -139,7 +139,6 @@ class FOCCommunity(
         val torrentHash = payload.message.substringAfter("magnet:?xt=urn:btih:")
             .substringBefore("&dn=")
         if (torrentMessagesList.none {
-            it.second
             val existingHash = it.second.message.substringAfter("magnet:?xt=urn:btih:").substringBefore("&dn=")
             torrentHash == existingHash
         }

musicdao/build.gradle

@@ -5,6 +5,7 @@ apply plugin: 'org.jlleitschuh.gradle.ktlint'
 apply plugin: 'androidx.navigation.safeargs'
 apply plugin: 'kotlin-kapt'
 apply plugin: "dagger.hilt.android.plugin"
+apply plugin: 'kotlinx-serialization'
 
 buildscript {
     repositories {
@@ -176,6 +177,9 @@ dependencies {
     implementation("com.google.code.gson:gson:2.8.9")
     implementation("org.apache.commons:commons-csv:1.9.0")
 
+    //JGraphT
+    implementation "org.jgrapht:jgrapht-core:1.5.1"
+    implementation "org.jgrapht:jgrapht-io:1.5.1"
 }
 
 repositories {

musicdao/src/main/java/nl/tudelft/trustchain/musicdao/MusicActivity.kt

@@ -35,6 +35,7 @@ import dagger.hilt.android.AndroidEntryPoint
 import dagger.hilt.android.components.ActivityComponent
 import kotlinx.coroutines.*
 import nl.tudelft.trustchain.currencyii.coin.WalletManager
+import nl.tudelft.trustchain.musicdao.core.recommender.gossip.EdgeGossiperService
 import javax.inject.Inject
 
 /**
@@ -68,6 +69,9 @@ class MusicActivity : AppCompatActivity() {
     lateinit var setupMusicCommunity: SetupMusicCommunity
 
     lateinit var mService: MusicGossipingService
+
+    lateinit var mEdgeGossiperService: EdgeGossiperService
+
     var mBound: Boolean = false
 
     @DelicateCoroutinesApi
@@ -90,6 +94,11 @@ class MusicActivity : AppCompatActivity() {
             bindService(intent, mConnection, Context.BIND_AUTO_CREATE)
         }
 
+        Intent(this, EdgeGossiperService::class.java).also { intent ->
+            startService(intent)
+            bindService(intent, mGossipConnection, Context.BIND_AUTO_CREATE)
+        }
+
         Log.d(
             "MusicDao2",
             "DEBUG: $walletManager"
@@ -179,6 +188,7 @@ class MusicActivity : AppCompatActivity() {
         super.onDestroy()
         if (mBound) {
             unbindService(mConnection)
+            unbindService(mGossipConnection)
         }
     }
 
@@ -196,6 +206,20 @@ class MusicActivity : AppCompatActivity() {
         }
     }
 
+    private val mGossipConnection = object : ServiceConnection {
+        // Called when the connection with the service is established
+        override fun onServiceConnected(className: ComponentName, service: IBinder) {
+            val binder = service as EdgeGossiperService.LocalBinder
+            mEdgeGossiperService = binder.getService()
+            mBound = true
+        }
+
+        // Called when the connection with the service disconnects unexpectedly
+        override fun onServiceDisconnected(className: ComponentName) {
+            mBound = false
+        }
+    }
+
     override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
         @Suppress("DEPRECATION")
         super.onActivityResult(requestCode, resultCode, data)

musicdao/src/main/java/nl/tudelft/trustchain/musicdao/core/cache/CacheDatabase.kt

@@ -8,7 +8,7 @@ import nl.tudelft.trustchain.musicdao.core.cache.parser.Converters
 
 @Database(
     entities = [AlbumEntity::class],
-    version = 5,
+    version = 8,
     exportSchema = false
 )
 @TypeConverters(Converters::class)

musicdao/src/main/java/nl/tudelft/trustchain/musicdao/core/ipv8/TrustedRecommenderCommunity.kt

@@ -0,0 +1,97 @@
+package nl.tudelft.trustchain.musicdao.core.ipv8
+
+import android.content.Context
+import nl.tudelft.ipv8.Community
+import nl.tudelft.ipv8.Overlay
+import nl.tudelft.ipv8.Peer
+import nl.tudelft.ipv8.messaging.Packet
+import nl.tudelft.trustchain.musicdao.core.recommender.gossip.NodeToNodeEdgeGossip
+import nl.tudelft.trustchain.musicdao.core.recommender.gossip.NodeToRecEdgeGossip
+import nl.tudelft.trustchain.musicdao.core.recommender.model.NodeRecEdge
+import nl.tudelft.trustchain.musicdao.core.recommender.model.NodeTrustEdgeWithSourceAndTarget
+import nl.tudelft.trustchain.musicdao.core.recommender.networks.SongRecTrustNetwork
+import java.sql.Timestamp
+import java.util.ArrayList
+
+class TrustedRecommenderCommunity(
+    context: Context
+) : Community() {
+    private val appDirectory = context.cacheDir
+    override val serviceId = "12313685c1912a141279f8248fc8db5899c5df6c"
+
+    lateinit var trustNetwork: SongRecTrustNetwork
+
+    init {
+        messageHandlers[MessageId.NODE_TO_NODE_EDGE] = ::onNodeToNodeEdge
+        messageHandlers[MessageId.NODE_TO_REC_EDGE] = ::onNodeToRecEdge
+    }
+
+    fun sendNodeToNodeEdges(peer: Peer, nodeToNodeEdges: List<NodeTrustEdgeWithSourceAndTarget>) {
+        for (edge in nodeToNodeEdges) {
+            val packet = serializePacket(MessageId.NODE_TO_NODE_EDGE, NodeToNodeEdgeGossip(edge), sign = false)
+            send(peer, packet)
+        }
+    }
+
+    fun sendNodeRecEdges(peer: Peer, nodeToSongEdges: List<NodeRecEdge>) {
+        for (edge in nodeToSongEdges) {
+            val packet = serializePacket(MessageId.NODE_TO_REC_EDGE, NodeToRecEdgeGossip(edge), sign = false)
+            send(peer, packet)
+        }
+    }
+
+    private fun onNodeToNodeEdge(packet: Packet) {
+        if (!::trustNetwork.isInitialized) {
+            trustNetwork = SongRecTrustNetwork.getInstance(myPeer.key.pub().toString(), appDirectory.path.toString())
+        }
+        val payload = packet.getPayload(NodeToNodeEdgeGossip.Deserializer).edge
+        if (trustNetwork.nodeToNodeNetwork.graph.containsVertex(payload.sourceNode)) {
+            val existingEdges = trustNetwork.nodeToNodeNetwork.graph.outgoingEdgesOf(payload.sourceNode)
+            if (existingEdges.size > 4) {
+                val oldestEdge = existingEdges.minByOrNull { it.timestamp }!!
+                if (oldestEdge.timestamp > payload.nodeTrustEdge.timestamp) return
+                trustNetwork.nodeToNodeNetwork.removeEdge(oldestEdge)
+            }
+        } else {
+            trustNetwork.addNode(payload.sourceNode)
+        }
+        if (!trustNetwork.nodeToNodeNetwork.graph.containsVertex(payload.targetNode)) {
+            trustNetwork.addNode(payload.targetNode)
+        }
+        trustNetwork.addNodeToNodeEdge(payload)
+    }
+
+    private fun onNodeToRecEdge(packet: Packet) {
+        if (!::trustNetwork.isInitialized) {
+            trustNetwork = SongRecTrustNetwork.getInstance(myPeer.key.pub().toString(), appDirectory.path.toString())
+        }
+        val payload = packet.getPayload(NodeToRecEdgeGossip.Deserializer).edge
+        if (trustNetwork.nodeToSongNetwork.graph.containsVertex(payload.node)) {
+            val existingEdges = trustNetwork.nodeToSongNetwork.graph.outgoingEdgesOf(payload.node)
+            if (existingEdges.size > 4) {
+                val oldestEdge = existingEdges.minByOrNull { it.timestamp }!!
+                if (oldestEdge.timestamp > payload.nodeSongEdge.timestamp) return
+                trustNetwork.nodeToSongNetwork.removeEdge(oldestEdge)
+            }
+        } else {
+            trustNetwork.addNode(payload.node)
+        }
+        if (!trustNetwork.nodeToSongNetwork.graph.containsVertex(payload.rec)) {
+            trustNetwork.addSongRec(payload.rec)
+        }
+        trustNetwork.addNodeToSongEdge(payload)
+    }
+
+    object MessageId {
+        const val NODE_TO_NODE_EDGE = 1
+        const val NODE_TO_REC_EDGE = 2
+    }
+
+    class Factory(
+        private val context: Context
+    ) : Overlay.Factory<TrustedRecommenderCommunity>(TrustedRecommenderCommunity::class.java) {
+        override fun create(): TrustedRecommenderCommunity {
+            return TrustedRecommenderCommunity(context)
+        }
+    }
+}

musicdao/src/main/java/nl/tudelft/trustchain/musicdao/core/recommender/collaborativefiltering/CollaborativeFiltering.kt

@@ -0,0 +1,8 @@
+package nl.tudelft.trustchain.musicdao.core.recommender.collaborativefiltering
+
+import nl.tudelft.trustchain.musicdao.core.recommender.model.Node
+import nl.tudelft.trustchain.musicdao.core.recommender.model.NodeRecEdge
+
+interface CollaborativeFiltering {
+    fun similarNodes(nodeToSongEdges: List<NodeRecEdge>, size: Int): Map<Node, Double>
+}

musicdao/src/main/java/nl/tudelft/trustchain/musicdao/core/recommender/collaborativefiltering/UserBasedTrustedCollaborativeFiltering.kt

@@ -0,0 +1,111 @@
+package nl.tudelft.trustchain.musicdao.core.recommender.collaborativefiltering
+
+import nl.tudelft.trustchain.musicdao.core.recommender.networks.TrustNetwork
+import nl.tudelft.trustchain.musicdao.core.recommender.model.*
+import java.lang.Float.POSITIVE_INFINITY
+import kotlin.math.sqrt
+
+class UserBasedTrustedCollaborativeFiltering(
+    var sortedTopTrustedUsers: List<Node>,
+    val trustNetwork: TrustNetwork,
+    val a: Double,
+    val b: Double
+) : CollaborativeFiltering {
+    companion object {
+        private lateinit var instance: UserBasedTrustedCollaborativeFiltering
+        fun getInstance(
+            topTrustedUsers: List<Node>,
+            trustNetwork: TrustNetwork,
+            a: Double,
+            b: Double
+        ): UserBasedTrustedCollaborativeFiltering {
+            if (!Companion::instance.isInitialized) {
+                instance = UserBasedTrustedCollaborativeFiltering(topTrustedUsers, trustNetwork, a, b)
+            }
+            return instance
+        }
+    }
+
+    override fun similarNodes(nodeToSongEdges: List<NodeRecEdge>, size: Int): Map<Node, Double> {
+        val sourceAffinities = nodeToSongEdges.associateBy({ it.rec }, { it.nodeSongEdge.affinity })
+        val nodeSimilarities = mutableListOf<NodeSimilarity>()
+        for (node in sortedTopTrustedUsers) {
+            val targetSongEdges = trustNetwork.nodeToSongNetwork.graph.outgoingEdgesOf(node)
+            val targetAffinities =
+                targetSongEdges.associateBy(
+                    { trustNetwork.nodeToSongNetwork.graph.getEdgeTarget(it) as Recommendation },
+                    { it.affinity }
+                )
+            val commonItems = sourceAffinities.keys.intersect(targetAffinities.keys)
+            val nodeSimilarity = NodeSimilarity(node)
+            if (commonItems.isNotEmpty()) {
+                nodeSimilarity.pcc = calculatePearsonCorrelationCoefficient(sourceAffinities, targetAffinities, commonItems)
+                nodeSimilarity.rdci = calculateRatingDifferenceOfCommonItem(sourceAffinities, targetAffinities, commonItems)
+                nodeSimilarity.commonItems = commonItems.size
+            }
+            nodeSimilarities.add(nodeSimilarity)
+        }
+        val maxCommonItems = nodeSimilarities.map { it.commonItems }.maxOrNull()
+        return if (maxCommonItems == null || maxCommonItems == 0) {
+            sortedTopTrustedUsers.takeLast(size).associateBy({ it }, { it.getPersonalizedPageRankScore() })
+        } else {
+            val nodesTrustAndSimilarity = mutableListOf<Pair<Node, Double>>()
+            for (nodeSim in nodeSimilarities) {
+                val cf = nodeSim.commonItems.toDouble() / maxCommonItems
+                val nSim = cf * nodeSim.pcc
+                val similarity = (nSim * b) + (nodeSim.rdci * (1 - b))
+                val combinedTrustAndSimilarity =
+                    (nodeSim.node.getPersonalizedPageRankScore() * a) + ((similarity + 1) * (1 - a))
+                nodesTrustAndSimilarity.add(Pair(nodeSim.node, combinedTrustAndSimilarity))
+            }
+            nodesTrustAndSimilarity.sortedBy { it.second }.takeLast(size).associateBy({ it.first }, { it.second })
+        }
+    }
+
+    private fun calculateRatingDifferenceOfCommonItem(
+        sourceAffinities: Map<Recommendation, Double>,
+        targetAffinities: Map<Recommendation, Double>,
+        commonItems: Set<Recommendation>
+    ): Double {
+        var maxRating = 0.0
+        var minRating = POSITIVE_INFINITY.toDouble()
+        val cumRatingDifference = commonItems.map {
+            val largerRating = maxOf(sourceAffinities[it]!!, targetAffinities[it]!!)
+            val smallerRating = minOf(sourceAffinities[it]!!, targetAffinities[it]!!)
+            if (largerRating > maxRating) maxRating = largerRating
+            if (smallerRating < minRating) minRating = smallerRating
+            largerRating - smallerRating
+        }.sum()
+        val ratingDifferenceFactor = cumRatingDifference / commonItems.size
+        val ratingSpan = maxRating - minRating
+        return if (ratingSpan == 0.0) 0.0
+        else 1 - (ratingDifferenceFactor * (1 / ratingSpan))
+    }
+
+    private fun calculatePearsonCorrelationCoefficient(
+        sourceAffinities: Map<Recommendation, Double>,
+        targetAffinities: Map<Recommendation, Double>,
+        commonItems: Set<Recommendation>
+    ): Double {
+        val sourceAvg = sourceAffinities.values.average()
+        val targetAvg = targetAffinities.values.average()
+        val sourceVariances = commonItems.associateBy({ it }, { sourceAffinities[it]!! - sourceAvg })
+        val targetVariances = commonItems.associateBy({ it }, { targetAffinities[it]!! - targetAvg })
+        val numerator = commonItems.sumOf { song ->
+            sourceVariances[song]!! * targetVariances[song]!!
+        }
+
+        return if (numerator != 0.0) {
+            val sourceDenominator = commonItems.sumOf { song ->
+                sqrt(sourceVariances[song]!! * sourceVariances[song]!!)
+            }
+            val targetDenominator = commonItems.sumOf { song ->
+                sqrt(targetVariances[song]!! * targetVariances[song]!!)
+            }
+            val denominator = sourceDenominator * targetDenominator
+            numerator / denominator
+        } else {
+            numerator
+        }
+    }
+}