Can a Neural Network be Created to Identify the Composer of a Single Song with Python and Tensorflow?

I would like to propose a theoretical question. Recently, I have been attempting to complete an experiment involving a neural network. Here are the parameters for my experiment and the specifications for what I require:

  • The program must be easily run in IDLE using a pip-installed edition of Tensorflow or Keras (running Tensorflow backend).

-In order for the experiment to produce results, I need to be able to change the number of hidden layers in the neural network and the number of nodes per layer.

  • My experiment will involve training the network using 25 songs, 5 per classical composer used and be able to identify the composers of 5 songs. I must not have to install any other tool besides Tensorflow for Python, IDLE, Librosa and/or Keras.

  • I must be able to interpret the guesses provided by the algorithm as direct string responses or numerical responses per composer.

I would appreciate any assistance a developer could offer me on this matter. I am, as of yet, rather inexperienced in such matters and have very little time to find a solution to this problem. Thank you for any assistance you can provide.

How can I identify duplicate image files?

Over the years, I’ve accumulated a lot of pictures, across a bunch of different machines.

I think I’ve mostly kept them in a yyyy/mm/ directory structure, but especially with some of the older pictures, there seem to be a lot of duplicates.

What’s the best way to identify the duplicates? Are there good tools to do this, or am I going to have to write something on my own?

How to identify the final set of “contours” when combining multiple primitive contours

This problem is in relation to how fonts work. Say you have a “glyph” that is composed of of these 5 “contours”, or enclosed loops.

enter image description here

On their own, each of them is a unified whole. The easiest thing we could possibly do is just blend/merge them all into one big mass, and take the outer edge to be the “new contour”.

But instead I am looking at it different, and getting confused along the way.

Say that each contour was laid down one at a time, in this order:

  1. black
  2. pink
  3. blue
  4. green
  5. yellow

So we start with the black and look at it as a whole.

enter image description here

Now we lay the pink one over the black one, but it clips or masks the black one underneath. That is, like a cookie cutter. There are two options:

  1. The pink is completely a cookie cutter and has no “solid” surface.
  2. Or, only the part of the pink that overlaps with the black is a cookie cutter, removing both the pink and the black, but leaving the rest of the pink and black available.

Just going to go with that.

That leaves with this:

enter image description here

Not too bad, visibly we have 2 complete isolated contours.

Now we add the blue, but this time it isn’t cookie cutter, it just goes on top. But the end result is it isolates two parts of the black now.

enter image description here

Next is green. There are two major cases I want to handle. One is this, where it just cookie cuts the pink, but overlays on the rest of them.

This leaves the green with a big hole in the center.

enter image description here

If instead of that, it took a different path, it ends up with a white space in side of it. To get there, it passes through the pink, overlays the blue, and cookie cuts the black.

enter image description here

Actually on the right there’s white too, and it touches the boundary of the other colored contours. So not sure about that. But in this case, the green no longer completely surrounds the pink, it shares a border with this, so hmm, maybe it does still technically engulf the whole contour.

Finally there’s yellow. Yellow gets split by green so there’s two isolated yellows.

enter image description here

So what we’ve just described here is a bunch of state changes to the system. We have all the basic data of the points and curves that defined the original shapes let’s say.

Essentially what I’m confused about is how to determine, at this final state, what all the boundaries are. This have been split and cookie cut and overlayed and such, I am having a hard time seeing how you can go from the simple initial state of the pure original contours, to this final state of many contours with unknown properties.

For example, the white spot in the middle of the green one, I am wondering if this would be considered a nested contour of some sort. Or when the pink was covered by the green, if that means that there is a nested contour.

Essentially my question is how to iterate through the final data structure to get a list of all the resulting contours. I don’t even know what the final data structure is. I know the initial one was a set of contours defined by a set of points. But when these transformation/splitting/merging operations occur, I am not sure if I should rebuild a complete list of all contours given this next step, or if it’s better/easier to wait until the final state, and you can ignore all the intermediate processing steps.

Any help clarifying this problem and how to get the final list of contours (and potentially nested contours) would be very helpful.

I would also like to handle if these objects were dynamically moving, making it more than static.

How to identify test cases?

I wrote a small INI file parser as a library which I want to use in a bigger project. Following good practice I decided I should write test cases, too. But I fail to find a good start.

  • The library is extremely small (1 source file for the implementation, 1 header)
  • The library has few public methods. (parse(), get_sections(), get_value(section, key))
  • Most logic is private to the implementation, therefore not trivially accessible for tests.
  • The input for a test would be an INI file and I don’t want to write multiple test INI files.

So the first test I’d write is:

  • Call the parse method on a provided test input INI file and check that it was successful.
  • Hardcoding expected sections and key-value pairs in the test itself and check that all of them are there.
  • Also check that no other sections and key-value pairs were extracted.

I am unhappy with that. Maintaining the expected output and the input files is quite a burden. The tests will fail when you update the input but not the expectations which I think is a bad design decision for tests.

There are many guidelines for writing good tests out there, but I always find it hard to apply them. I guess experience is the key. So maybe you can guide me to some good example codes or share your personal experiences? Much appreciated.

How can I identify the cache if I see its name? One belongs to malware

If Device maintenance app is launched in Samsung S8, after pressing Clean Now button, storage cleanup briefly shows different apps, storage space of which is being cleaned:

System cache OneNote TopBuzz 

I know that the last one is a malware and is not present in my list of apps, but how can I find out to which app it actually belongs? No antivirus which I tried so far reported this as a malware. But maybe there is some system analyzer which shows similar cache ownership like the above app, but with more details?

(Or maybe there is another method how to find origin of that TopBuzz symptom.)

The phone is not rooted.

Looking for an algorithm to identify repeated series of lines in a long string

I would like an algorithm that can identify repeated parts of big stack traces like this:

java.lang.StackOverflowError at transform.Erasure$  Eraser.typed1(Erasure.scala:789) at typechecker.Typers$  Typer.runTyper$  1(Typers.scala:5640) at typechecker.Typers$  Typer.typedInternal(Typers.scala:5672) at typechecker.Typers$  Typer.body$  2(Typers.scala:5613) at typechecker.Typers$  Typer.typed(Typers.scala:5618) at typechecker.Typers$  Typer.$  anonfun$  typed1$  38(Typers.scala:4752) at typechecker.Typers$  Typer.silent(Typers.scala:700) at typechecker.Typers$  Typer.normalTypedApply$  1(Typers.scala:4754) at typechecker.Typers$  Typer.typedApply$  1(Typers.scala:4801) at typechecker.Typers$  Typer.typedInAnyMode$  1(Typers.scala:5586) at typechecker.Typers$  Typer.typed1(Typers.scala:5603) at transform.Erasure$  Eraser.typed1(Erasure.scala:789) at typechecker.Typers$  Typer.runTyper$  1(Typers.scala:5640) at typechecker.Typers$  Typer.typedInternal(Typers.scala:5672) at typechecker.Typers$  Typer.body$  2(Typers.scala:5613) at typechecker.Typers$  Typer.typed(Typers.scala:5618) at typechecker.Typers$  Typer.typedQualifier(Typers.scala:5723) at typechecker.Typers$  Typer.typedQualifier(Typers.scala:5731) at transform.Erasure$  Eraser.adaptMember(Erasure.scala:714) at transform.Erasure$  Eraser.typed1(Erasure.scala:789) at typechecker.Typers$  Typer.runTyper$  1(Typers.scala:5640) at typechecker.Typers$  Typer.typedInternal(Typers.scala:5672) at typechecker.Typers$  Typer.body$  2(Typers.scala:5613) at typechecker.Typers$  Typer.typed(Typers.scala:5618) at typechecker.Typers$  Typer.$  anonfun$  typed1$  38(Typers.scala:4752) at typechecker.Typers$  Typer.silent(Typers.scala:700) at typechecker.Typers$  Typer.normalTypedApply$  1(Typers.scala:4754) at typechecker.Typers$  Typer.typedApply$  1(Typers.scala:4801) at typechecker.Typers$  Typer.typedInAnyMode$  1(Typers.scala:5586) at typechecker.Typers$  Typer.typed1(Typers.scala:5603) at transform.Erasure$  Eraser.typed1(Erasure.scala:789) at typechecker.Typers$  Typer.runTyper$  1(Typers.scala:5640) at typechecker.Typers$  Typer.typedInternal(Typers.scala:5672) at typechecker.Typers$  Typer.body$  2(Typers.scala:5613) at typechecker.Typers$  Typer.typed(Typers.scala:5618) at typechecker.Typers$  Typer.typedQualifier(Typers.scala:5723) at typechecker.Typers$  Typer.typedQualifier(Typers.scala:5731) at transform.Erasure$  Eraser.adaptMember(Erasure.scala:714) at transform.Erasure$  Eraser.typed1(Erasure.scala:789) at typechecker.Typers$  Typer.runTyper$  1(Typers.scala:5640) at typechecker.Typers$  Typer.typedInternal(Typers.scala:5672) at typechecker.Typers$  Typer.body$  2(Typers.scala:5613) at typechecker.Typers$  Typer.typed(Typers.scala:5618) at typechecker.Typers$  Typer.$  anonfun$  typed1$  38(Typers.scala:4752) at typechecker.Typers$  Typer.silent(Typers.scala:700) at typechecker.Typers$  Typer.normalTypedApply$  1(Typers.scala:4754) at typechecker.Typers$  Typer.typedApply$  1(Typers.scala:4801) at typechecker.Typers$  Typer.typedInAnyMode$  1(Typers.scala:5586) at typechecker.Typers$  Typer.typed1(Typers.scala:5603) at transform.Erasure$  Eraser.typed1(Erasure.scala:789) at typechecker.Typers$  Typer.runTyper$  1(Typers.scala:5640) at typechecker.Typers$  Typer.typedInternal(Typers.scala:5672) at typechecker.Typers$  Typer.body$  2(Typers.scala:5613) at typechecker.Typers$  Typer.typed(Typers.scala:5618) at typechecker.Typers$  Typer.typedQualifier(Typers.scala:5723) at typechecker.Typers$  Typer.typedQualifier(Typers.scala:5731) at transform.Erasure$  Eraser.adaptMember(Erasure.scala:714) at transform.Erasure$  Eraser.typed1(Erasure.scala:789) at typechecker.Typers$  Typer.runTyper$  1(Typers.scala:5640) at typechecker.Typers$  Typer.typedInternal(Typers.scala:5672) at typechecker.Typers$  Typer.body$  2(Typers.scala:5613) at typechecker.Typers$  Typer.typed(Typers.scala:5618) at typechecker.Typers$  Typer.$  anonfun$  typed1$  38(Typers.scala:4752) 

With a bit of inspection, it’s clear that this segment is being repeated three times:

at typechecker.Typers$  Typer.runTyper$  1(Typers.scala:5640) at typechecker.Typers$  Typer.typedInternal(Typers.scala:5672) at typechecker.Typers$  Typer.body$  2(Typers.scala:5613) at typechecker.Typers$  Typer.typed(Typers.scala:5618) at typechecker.Typers$  Typer.$  anonfun$  typed1$  38(Typers.scala:4752) at typechecker.Typers$  Typer.silent(Typers.scala:700) at typechecker.Typers$  Typer.normalTypedApply$  1(Typers.scala:4754) at typechecker.Typers$  Typer.typedApply$  1(Typers.scala:4801) at typechecker.Typers$  Typer.typedInAnyMode$  1(Typers.scala:5586) at typechecker.Typers$  Typer.typed1(Typers.scala:5603) at transform.Erasure$  Eraser.typed1(Erasure.scala:789) at typechecker.Typers$  Typer.runTyper$  1(Typers.scala:5640) at typechecker.Typers$  Typer.typedInternal(Typers.scala:5672) at typechecker.Typers$  Typer.body$  2(Typers.scala:5613) at typechecker.Typers$  Typer.typed(Typers.scala:5618) at typechecker.Typers$  Typer.typedQualifier(Typers.scala:5723) at typechecker.Typers$  Typer.typedQualifier(Typers.scala:5731) at transform.Erasure$  Eraser.adaptMember(Erasure.scala:714) at transform.Erasure$  Eraser.typed1(Erasure.scala:789) 

The end goal is so I can print out stack traces of recursive functions in a nicer fashion

java.lang.StackOverflowError at transform.Erasure$  Eraser.typed1(Erasure.scala:789) ------------------------- Repeated 3x ------------------------- at typechecker.Typers$  Typer.runTyper$  1(Typers.scala:5640) at typechecker.Typers$  Typer.typedInternal(Typers.scala:5672) at typechecker.Typers$  Typer.body$  2(Typers.scala:5613) at typechecker.Typers$  Typer.typed(Typers.scala:5618) at typechecker.Typers$  Typer.$  anonfun$  typed1$  38(Typers.scala:4752) at typechecker.Typers$  Typer.silent(Typers.scala:700) at typechecker.Typers$  Typer.normalTypedApply$  1(Typers.scala:4754) at typechecker.Typers$  Typer.typedApply$  1(Typers.scala:4801) at typechecker.Typers$  Typer.typedInAnyMode$  1(Typers.scala:5586) at typechecker.Typers$  Typer.typed1(Typers.scala:5603) at transform.Erasure$  Eraser.typed1(Erasure.scala:789) at typechecker.Typers$  Typer.runTyper$  1(Typers.scala:5640) at typechecker.Typers$  Typer.typedInternal(Typers.scala:5672) at typechecker.Typers$  Typer.body$  2(Typers.scala:5613) at typechecker.Typers$  Typer.typed(Typers.scala:5618) at typechecker.Typers$  Typer.typedQualifier(Typers.scala:5723) at typechecker.Typers$  Typer.typedQualifier(Typers.scala:5731) at transform.Erasure$  Eraser.adaptMember(Erasure.scala:714) at transform.Erasure$  Eraser.typed1(Erasure.scala:789) ------------------------------------------------------------- at typechecker.Typers$  Typer.runTyper$  1(Typers.scala:5640) at typechecker.Typers$  Typer.typedInternal(Typers.scala:5672) at typechecker.Typers$  Typer.body$  2(Typers.scala:5613) at typechecker.Typers$  Typer.typed(Typers.scala:5618) at typechecker.Typers$  Typer.$  anonfun$  typed1$  38(Typers.scala:4752) 

I’m not sure how feasible this is, but I’d be happy for any and all possible solutions even if they have their own limitations and constraints. Preliminary Googling didn’t find me anything, but quite likely I just don’t know what to google