Gerador de lista de reprodução alimentada por IA: criando visualizações personalizadas com aprendizagem profunda4j e MongoDB

1
<dependencies>
2
    <!-- Spring Boot Starter for Web API -->
3
    <dependency>
4
        <groupId>org.springframework.boot</groupId>
5
        <artifactId>spring-boot-starter-web</artifactId>
6
    </dependency>
7
8
    <!-- ND4J: Core Numerical Processing -->
9
    <dependency>
10
        <groupId>org.nd4j</groupId>
11
        <artifactId>${nd4j.backend}</artifactId>
12
        <version>${1.0.0-M2.1}</version>
13
    </dependency>
14
15
    <!-- DataVec for working with data -->
16
    <dependency>
17
        <groupId>org.datavec</groupId>
18
        <artifactId>datavec-api</artifactId>
19
        <version>${1.0.0-M2.1}</version>
20
    </dependency>
21
22
    <!-- DeepLearning4j Core -->
23
    <dependency>
24
        <groupId>org.deeplearning4j</groupId>
25
        <artifactId>deeplearning4j-core</artifactId>
26
        <version>${1.0.0-M2.1}</version>
27
    </dependency>
28
29
    <!-- DeepLearning4j NLP for Text Processing -->
30
    <dependency>
31
        <groupId>org.deeplearning4j</groupId>
32
        <artifactId>deeplearning4j-nlp</artifactId>
33
        <version>${1.0.0-M2.1}</version>
34
    </dependency>
35
36
    <!-- Apache Commons CSV -->
37
    <dependency>
38
        <groupId>org.apache.commons</groupId>
39
        <artifactId>commons-csv</artifactId>
40
        <version>1.9.0</version>
41
    </dependency>
42
43
    <!-- MongoDB Driver -->
44
    <dependency>
45
        <groupId>org.mongodb</groupId>
46
        <artifactId>mongodb-driver-sync</artifactId>
47
        <version>5.2.0</version>
48
    </dependency>
49
50
    <dependency>
51
        <groupId>org.mongodb</groupId>
52
        <artifactId>mongodb-driver-core</artifactId>
53
        <version>5.2.0</version>
54
    </dependency>
55
56
    <dependency>
57
        <groupId>org.mongodb</groupId>
58
        <artifactId>bson</artifactId>
59
        <version>5.2.0</version>
60
    </dependency>
61
62
    <!-- JUnit for testing -->
63
    <dependency>
64
        <groupId>org.junit.jupiter</groupId>
65
        <artifactId>junit-jupiter-api</artifactId>
66
        <version>5.7.0</version>
67
        <scope>test</scope>
68
    </dependency>
69
70
</dependencies>

1
import java.util.List;  
2
  
3
public class Song {  
4
    private String title;  
5
    private String artist;  
6
    private String lyrics;  
7
    private List<Double> embedding;  
8
  
9
    public Song(String title, String artist, String lyrics, List<Double> embedding) {  
10
        this.title = title;  
11
        this.artist = artist;  
12
        this.lyrics = lyrics;  
13
        this.embedding = embedding;  
14
    }  
15
  
16
    public String getTitle() {  
17
        return title;  
18
    }  
19
  
20
    public void setTitle(String title) {  
21
        this.title = title;  
22
    }  
23
  
24
    public String getArtist() {  
25
        return artist;  
26
    }  
27
  
28
    public void setArtist(String artist) {  
29
        this.artist = artist;  
30
    }  
31
  
32
    public String getLyrics() {  
33
        return lyrics;  
34
    }  
35
  
36
    public void setLyrics(String lyrics) {  
37
        this.lyrics = lyrics;  
38
    }  
39
  
40
    public List<Double> getEmbedding() {  
41
        return embedding;  
42
    }  
43
  
44
    public void setEmbedding(List<Double> embedding) {  
45
        this.embedding = embedding;  
46
    }  
47
}

1
import java.util.List;  
2
  
3
public class Playlist {  
4
  
5
    private String playlistName;  
6
    private List<Song> songs;  
7
  
8
    public Playlist() {  
9
    }  
10
  
11
    public Playlist(String playlistName, List<Song> songs) {  
12
        this.playlistName = playlistName;  
13
        this.songs = songs;  
14
    }  
15
  
16
    public String getPlaylistName() {  
17
        return playlistName;  
18
    }  
19
  
20
    public void setPlaylistName(String playlistName) {  
21
        this.playlistName = playlistName;  
22
    }  
23
  
24
    public List<Song> getSongs() {  
25
        return songs;  
26
    }  
27
  
28
    public void setSongs(List<Song> songs) {  
29
        this.songs = songs;  
30
    }  
31
}

1
@Service
2
public class EmbeddingService {
3
4
private final Map<String, INDArray> gloveEmbeddings = new HashMap<>();  
5
private final DefaultTokenizerFactory tokenizerFactory = new DefaultTokenizerFactory();  
6
private final Set<String> stopWords;  // Set of stop words for filtering  
7
  
8
@Value("${embedding.model.path}")  
9
private String preTrainedGlovePath;  
10
  
11
public EmbeddingService() {  
12
    tokenizerFactory.setTokenPreProcessor(new CommonPreprocessor());  
13
    stopWords = loadStopWords();  
14
}  
15
   
16
@PostConstruct  
17
private void init() throws IOException {  
18
    loadGloveModel(preTrainedGlovePath);  
19
}  
20
  
21
private void loadGloveModel(String preTrainedGlovePath) throws IOException {  
22
    InputStream gloveStream = getClass().getResourceAsStream("/glove.840B.300d.txt");  
23
    if (gloveStream == null) {  
24
        throw new IOException("GloVe model not found in resources: " + preTrainedGlovePath);  
25
    }  
26
  
27
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(gloveStream))) {  
28
        String line;  
29
        while ((line = reader.readLine()) != null) {  
30
            String[] split = line.split(" ");  
31
            String word = split[0];  
32
            float[] vector = new float[300];  // 300-dimensional GloVe vector  
33
            for (int i = 1; i < split.length; i++) {  
34
                vector[i - 1] = Float.parseFloat(split[i]);  
35
            }  
36
            INDArray wordVector = Nd4j.create(vector);  
37
            gloveEmbeddings.put(word, wordVector);  
38
        }  
39
    }  
40
}
41
42
private Set<String> loadStopWords() {  
43
    return new HashSet<>(Arrays.asList(  
44
            "the", "a", "an", "and", "is", "in", "at", "of", "to", "for", "with", "on", "by", "this", "that", "it", "i", "you", "they", "we", "but", "or", "as", "if", "when"  
45
    ));  
46
}

1
 private String removeBracketedText(String text) {  
2
    return text.replaceAll("\\[.*?]", "").trim();  
3
}  
4
  
5
public List<String> tokenizeText(String text) {  
6
    text = removeBracketedText(text);  
7
  
8
    Tokenizer tokenizer = tokenizerFactory.create(text);  
9
    List<String> tokens = new ArrayList<>();  
10
    while (tokenizer.hasMoreTokens()) {  
11
        String token = tokenizer.nextToken();  
12
        if (!stopWords.contains(token)) {  
13
            tokens.add(token);  
14
        }  
15
    }  
16
    return tokens;  
17
}

1
public INDArray getEmbeddingForWord(String word) {  
2
    return gloveEmbeddings.getOrDefault(word, null);  
3
}  
4
5
public List<Double> getEmbeddingForText(List<String> tokens) {  
6
    INDArray embedding = null;  
7
    int validTokenCount = 0;  
8
  
9
    for (String token : tokens) {  
10
        INDArray wordVector = getEmbeddingForWord(token);  
11
        if (wordVector != null) {  
12
            if (embedding == null) {  
13
                embedding = wordVector.dup();  // Duplicate the word vector  
14
            } else {  
15
                embedding.addi(wordVector);  // Sum the word embeddings  
16
            }  
17
            validTokenCount++;  
18
        }  
19
    }  
20
   
21
    if (embedding != null && validTokenCount > 0) {  
22
        embedding.divi(validTokenCount);  
23
        return convertINDArrayToDoubleList(embedding);  
24
    }  
25
    return Collections.emptyList();  // Return an empty list if no valid embeddings  
26
}  
27
  
28
private List<Double> convertINDArrayToDoubleList(INDArray indArray) {  
29
    double[] array = indArray.toDoubleVector();   
30
    List<Double> doubleList = new ArrayList<>();  
31
    for (double value : array) {  
32
        doubleList.add(value);  
33
    }  
34
    return doubleList;  
35
}  
36
   
37
public List<Double> embedText(String text) {  
38
    List<String> tokens = tokenizeText(text);  
39
    return getEmbeddingForText(tokens);  
40
}

1
import com.mongodb.client.MongoClient;  
2
import com.mongodb.client.MongoClients;  
3
import org.springframework.context.annotation.Bean;  
4
import org.springframework.context.annotation.Configuration;  
5
import org.springframework.beans.factory.annotation.Value;  
6
  
7
@Configuration  
8
public class MongoDBConfig {  
9
  
10
    @Value("${mongodb.uri}")  
11
    private String mongoUri;  
12
  
13
    @Bean  
14
    public MongoClient mongoClient() {  
15
        return MongoClients.create(mongoUri);
16
    }  
17
}

1
mongodb.uri=mongodb+srv://<username>:<password>@cluster.mongodb.net/?retryWrites=true&w=majority

1
mongodb.database=music  
2
mongodb.collection=songs

1
import com.mongodb.client.MongoClient;
2
import com.mongodb.client.MongoCollection;
3
import com.mongodb.client.MongoDatabase;
4
import org.bson.Document;
5
import org.example.model.Song;
6
import org.springframework.beans.factory.annotation.Value;
7
import org.springframework.stereotype.Repository;
8
9
import java.util.ArrayList;
10
import java.util.Arrays;
11
import java.util.List;
12
13
@Repository
14
public class MongoDBRepository {
15
16
    private final MongoCollection<Document> songCollection;
17
18
    public MongoDBRepository(MongoClient mongoClient,
19
                             @Value("${mongodb.database}") String databaseName,
20
                             @Value("${mongodb.collection}") String collectionName) {
21
        MongoDatabase database = mongoClient.getDatabase(databaseName);
22
        this.songCollection = database.getCollection(collectionName);
23
    }
24
25
    /**
26
     * Store the song embedding along with song details
27
     *
28
     * @param lyrics The song lyrics
29
     * @param title The song title
30
     * @param artist The artist name
31
     * @param embedding The vector embedding for the song
32
     */
33
    public void storeEmbedding(String lyrics, String title, String artist, List<Double> embedding) {
34
        Document songDocument = new Document()
35
                .append("title", title)
36
                .append("artist", artist)
37
                .append("lyrics", lyrics)
38
                .append("embedding", embedding);
39
        songCollection.insertOne(songDocument);
40
    }
41
42
    /**
43
     * Fetch similar songs using MongoDB's $vectorSearch aggregation based on the playlist embedding.
44
     *
45
     * @param playlistEmbedding The playlist title embedding used as the query vector
46
     * @return List of Song objects representing similar songs
47
     */
48
    public List<Song> getSimilarSongs(List<Double> playlistEmbedding) {
49
        List<Document> similarSongsDocs = new ArrayList<>();
50
51
        // Perform the vector search using the generated embedding
52
        String indexName = "vector_index";
53
        int numCandidates = 150;
54
        int limit = 10;
55
56
        List<Document> pipeline = Arrays.asList(
57
                new Document("$vectorSearch",
58
                        new Document("index", indexName)
59
                                .append("path", "embedding")
60
                                .append("queryVector", playlistEmbedding)
61
                                .append("numCandidates", numCandidates)
62
                                .append("limit", limit)
63
                ),
64
                new Document("$limit", limit)
65
        );
66
67
        try {
68
            songCollection.aggregate(pipeline).into(similarSongsDocs);
69
        } catch (Exception e) {
70
            throw new RuntimeException("Failed to retrieve similar songs", e);
71
        }
72
73
        
74
        List<Song> similarSongs = new ArrayList<>();
75
        for (Document doc : similarSongsDocs) {
76
            Song song = new Song(
77
                    doc.getString("title"),
78
                    doc.getString("artist"),
79
                    doc.getString("lyrics"),
80
                    doc.getList("embedding", Double.class)
81
            );
82
            similarSongs.add(song);
83
        }
84
85
        return similarSongs;
86
    }
87
}

1
{   
2
	"fields": [     
3
		{       
4
		"type": "vector",       
5
		"path": "embedding",       
6
		"numDimensions": 300,  // The number of dimensions of the vectors
7
		"similarity": "dotProduct"  // Similarity metric (cosine, euclidean, or dotProduct)
8
		}   
9
	] 
10
}

1
@Service
2
public class PlaylistService {
3
4
    private final EmbeddingService embeddingService;
5
    private final MongoDBRepository songRepository;
6
7
    public PlaylistService(EmbeddingService embeddingService, MongoDBRepository songRepository) {
8
        this.embeddingService = embeddingService;
9
        this.songRepository = songRepository;
10
    }
11
}

1
 public Playlist generatePlaylist(String playlistName) {  
2
    // Generate the embedding for the playlist title  
3
    List<Double> playlistEmbedding = embeddingService.embedText(playlistName);  
4
  
5
    if (playlistEmbedding == null || playlistEmbedding.isEmpty()) {  
6
        throw new RuntimeException("Failed to generate embedding for playlist: " + playlistName);  
7
    }  
8
  
9
    // Query the database to find similar songs  
10
    List<Song> similarSongs = songRepository.getSimilarSongs(playlistEmbedding);  
11
  
12
    // Construct and return the Playlist  
13
    return new Playlist(playlistName, similarSongs);  
14
}

1
import org.apache.commons.csv.CSVFormat;  
2
import org.apache.commons.csv.CSVParser;  
3
import org.apache.commons.csv.CSVRecord;  
4
import org.example.repository.MongoDBRepository;  
5
import org.example.service.EmbeddingService;  
6
import org.springframework.stereotype.Component;  
7
  
8
import java.io.InputStreamReader;  
9
import java.io.Reader;  
10
import java.util.List;  
11
import java.util.Objects;  
12
  
13
@Component  
14
public class SongLyricsProcessor {  
15
  
16
    private final EmbeddingService embeddingService;  
17
    private final MongoDBRepository mongoDBRepository;  
18
  
19
    public SongLyricsProcessor(EmbeddingService embeddingService, MongoDBRepository mongoDBRepository) {  
20
        this.embeddingService = embeddingService;  
21
        this.mongoDBRepository = mongoDBRepository;  
22
    }  
23
  
24
    public void processAndStoreLyrics(String csvFilePath) throws Exception {  
25
        Reader reader = new InputStreamReader(  
26
                Objects.requireNonNull(getClass().getClassLoader().getResourceAsStream(csvFilePath))  
27
        );  
28
  
29
        CSVFormat csvFormat = CSVFormat.DEFAULT.builder()  
30
                .setHeader()  
31
                .setSkipHeaderRecord(true)  
32
                .build();  
33
  
34
        CSVParser csvParser = new CSVParser(reader, csvFormat);  
35
  
36
        for (CSVRecord record : csvParser) {  
37
            String title = record.get("title");  
38
            String artist = record.get("artist");  
39
            String lyrics = record.get("lyrics");  
40
            String languageCld3 = record.get("language_cld3");  
41
            String languageFt = record.get("language_ft");  
42
  
43
            // Check if both language_cld3 and language_ft are 'en' (English)  
44
            if (!"en".equalsIgnoreCase(languageCld3) || !"en".equalsIgnoreCase(languageFt)) {  
45
                continue;  
46
            }  
47
  
48
            // Tokenize the lyrics and generate the embedding  
49
            List<Double> lyricsEmbedding = embeddingService.embedText(lyrics);  
50
  
51
            // Store the title, artist, lyrics, and embedding in MongoDB  
52
            mongoDBRepository.storeEmbedding(lyrics, title, artist, lyricsEmbedding);  
53
        }  
54
  
55
        csvParser.close();  
56
    }  
57
}

1
@RestController
2
public class PlaylistController {
3
4
    private final PlaylistService playlistService;
5
    private final SongLyricsProcessor songLyricsProcessor;
6
7
    public PlaylistController(PlaylistService playlistService, SongLyricsProcessor songLyricsProcessor) {
8
        this.playlistService = playlistService;
9
        this.songLyricsProcessor = songLyricsProcessor;
10
    }
11
12
    @GetMapping("/loadSampleData")
13
    public void loadSampleData(@RequestParam String fileName) throws Exception {
14
        songLyricsProcessor.processAndStoreLyrics(fileName);
15
    }
16
}

1
@GetMapping("/newPlaylist")
2
public Playlist newPlaylist(@RequestParam String playlistName) {
3
	return playlistService.generatePlaylist(playlistName);
4
}

1
curl -X GET "http://localhost:8080/loadSampleData?fileName=song_lyrics.csv"

1
curl -X GET "http://localhost:8080/newPlaylist?playlistName=sad%20girl%20wistful%20Friday%20evening"

1
{
2
	"playlistName": "sad girl wistful Friday evening",
3
	"songs": [
4
	    {
5
			"title": "When A Woman Loves",
6
			"artist": "R. Kelly",
7
			"lyrics": "...",
8
			"embedding": "...",
9
	    },
10
	    {
11
			"title": "Lonely",
12
			"artist": "Akon",
13
			"lyrics": "...",
14
			"embedding": "...",
15
	    },
16
	    {
17
			"title": "Monster",
18
			"artist": "Lady Gaga",
19
			"lyrics": "...",
20
			"embedding": "...",
21
	    },
22
	    {
23
			"title": "All the Boys",
24
			"artist": "Keri Hilson",
25
			"lyrics": "...",
26
			"embedding": "...",
27
	    }
28
	]
29
}