Adding logs to code or logging requests-responses in any application has become an essential part of programming these days. Nearly every software application contains TBs of log files. Often programmers take logging for granted because of easy logging frameworks like slf4j, log4j. We hardly worry about the role of logs in our application performance.

Logging is indeed essential, but we need to keep in mind the extent of its usage. So let’s discuss how much logging is healthy for a code. Here We have created a small code exercise to identify differences in the method execution time using methods containing log and dull method execution.

We have used Google Caliper for micro benchmarking my methods and Log4J for adding logs to the code.

import com.google.caliper.Runner;
import com.google.caliper.SimpleBenchmark;
import org.apache.log4j.Logger;

public class LoggingBenchMark extends SimpleBenchmark {
    final static Logger logger = Logger.getLogger(LoggingBenchMark.class);

    public static void main(String[] args) throws Exception {
        new Runner().run(
                LoggingBenchMark.class.getName()
        );
    }

    private static final int SET_SIZE = 100000;

    public void timeWithoutLog(int reps) throws InterruptedException {
        for (int i = 0; i < reps; i++) {
            for (int j = 0; j < SET_SIZE; j++) {
                try {
                    performSomething(j);
                } catch (Exception e) {
                }
            }
        }
    }


    public void timeWithPlainLog(int reps) throws InterruptedException {
        for (int i = 0; i < reps; i++) {
            for (int j = 0; j < SET_SIZE; j++) {
                try {
                    logger.info("testing logs adding here");
                    performSomething(j);
                } catch (Exception e) {
                }
            }
        }
    }

    public void timeWithLogExecively(int reps) {
        for (int i = 0; i < reps; i++) {
            for (int j = 0; j < 10000; j++) {
                try {
                    logger.info("testing logs adding here");
                    performSomething(j);
                } catch (Exception e) {
                    logger.error("exception in method : {}",e);
                }
                logger.debug("debug exception in method");

            }
            logger.info("some more logs");
        }
    }


    public void performSomething(int number) {
        if (number / 100 == 0) {
            throw new RuntimeException();
        }

    }
}

Just copy and run this code on your local, you will see the difference in the method execution time with log and without log is more than  2500%. With method performance, excessive logging also affects CPU usage for file I/O and the server space too.

The logging application flow is indeed necessary, but the overuse of logs to code flows has its drawbacks. Some ways of keeping logs to a minimum are by having a proper log level configured in the application, avoiding the use of calculations/fetching data in the logging statements.

The post How logging affect code performance? appeared first on CepstraResearch.

In music personalization, people tend to prefer a particular set of instruments over others. For instance, listeners may prefer a song with acoustic instruments like guitar and cello over electronically generated bass. For this purpose, we decided to dive into a branch of research that can distinguish between the songs containing a different set of instrument mixture and add this as a feature to the music recommendation system.

After a brief research period, we recognized that a certain set of instruments, if played together, produces a frequency that is similar to the same set of instruments played in a different song.

In other words, there seems to be a behavioral pattern that is followed when the same instruments are played together in different songs. This finding leads us to craft a code that can segregate these frequencies and help us improve the music recommendation system.

The song is loaded and chunked into lumps of 10 milliseconds file. The individual files are processed with Fast Fourier Transform (FFT) to convert the chunk from a time domain to a frequency domain. Since there are multiple frequencies present in the frequency band we needed the find the maximum frequency and load it into a list to further process it down.

To do this,  We study  FFT(Fast Fourier Transform) of the chunk of frequencies.

To calculate the frequency in hertz

When the frequency at every chunk is obtained, the task remains to segregate them to their respective frequency bands. We have given a summary of the theory on which we have based this research on.

The deepness of music is actually the low range frequency which produces the frequency range from 20 Hz to 200 Hz. That means any song having a base feature like a free kick in a soccer match will have a low-frequency range. The low frequencies have a greater wavelength, as a result, it sounds thick and deep. This frequency range is produced by 

Lower mid-range carries the musical bass in your song for example notes from a bass guitar, a low note in saxophone or a thick flute. You can think of it as the flooring of your music as it provides the heaviness to your music. This frequency range, as well as the higher mid-range, is produced by the surround of the diaphragm in a speaker.

The treble part lies between 1000 Hz to 5000 Hz of the song and this where most of the magic happens. From high-pitched voice to the guitar solos this is the most important part of the frequency regarding the melody and therefore it is also known as the full range of presence. This frequency is also the result of the surrounding part in a speaker.

This section of the frequency range above 5000Hz is the high pitched section. The bright music everyone talks about, that’s the outcome of the frequency in this range. The whistle and the sharp pieces of the triangle you hear in a piece of music belongs to this range. This frequency range is produced by a driver called tweeter in a speaker.

At Cepstra we study music keeping these values in the base of the algorithm, and generate various human-understandable characteristic of the music. 

The post Frequency Band Segregation appeared first on CepstraResearch.

In music personalization, listeners have a tendency to incline towards a single artist or if no similar songs available from the same artist listeners inclined towards listening songs from other artists have a similar style, language or from the artists who might belong to the same ethnic background. For example at mass, listeners may not like to switch the songs from Justin Bieber to Nusrat Fateh Ali Khan or from Skrillex to Alan Jackson. At Cepstra, we developed a pure Artificial Intelligence-based system that identifies and group artists with a similar style based on the information available on the world wide web.

We have a collection of artists’ information, including their career, area of expertise, music albums and songs, mixes, and other music-related productions gathered from various sources throughout the internet.

We executed an algorithm based on Latent semantic analysis, analyzing the relationship between a set of documents and the terms they contain by producing a set of concepts related to the materials.

LSA can be mathematically shown as,

Where,

is matrix defining similarity(co-occurrence).

&  are decomposition matrices for values k.

The collections of crawled content are converted into a matrix with the importance of different concepts throughout the artists’ information catalog, The model decomposed into its constituent parts in order to make precise subsequent matrix calculations simpler using Truncated Singular-Value Decomposition. This matrix is further normalized to its unit norm and based on similarity calculations, we create multiple groups of similar artists and their similarity strength.

The post Artist based personalization appeared first on CepstraResearch.