Memmingen FC: Champions League Aspirations & Squad Highlights

“””Implementation of common preprocessing steps.”””
import tensorflow.compat.v1 as tf

from magenta.models.nsynth import audio_processing

def preemphasis_frame(signal,
frame_length=25,
frame_step=10,
sample_rate=16000):
“””Pre-emphasis + framing.”””
# Preemphasis.
signal = audio_processing.preemphasis(signal)
# Framing.
signal = tf.signal.frame(
signal,
frame_length=int(round(frame_length * sample_rate)),
frame_step=int(round(frame_step * sample_rate)),
pad_end=True)
return signal

def stft_frame(signal,
frame_length=25,
frame_step=10,
fft_length=None,
sample_rate=16000):
“””STFT + framing.”””
if fft_length is None:
# Pad `frame_length` instead of `fft_length`.
fft_length = int(round(frame_length * sample_rate))
frames = tf.signal.frame(
signal,
frame_length=fft_length,
frame_step=int(round(frame_step * sample_rate)),
pad_end=True)
# Compute STFT per frame.
frames = tf.signal.stft(frames[:, :, tf.newaxis], fft_length)[…, :frames.shape[1]]
return frames

def get_hop_size_and_stft_kernel_size(hop_size_ms):
“””Returns hop size and kernel size given hop size ms.”””
hop_size = int(0.001 * hop_size_ms * FLAGS.sample_rate)
stft_kernel_size = hop_size * FLAGS.num_magnitudes + FLAGS.num_magnitudes // (
FLAGS.downsampled_stft // FLAGS.stft_stride) – FLAGS.stft_stride
return hop_size, stft_kernel_size

def stft_mag_phase(signal):
“””STFT magnitude/phase.”””
stfts = tf.signal.stft(
signal[:, :, tf.newaxis],
frame_length=FLAGS.stft_kernel_size,
frame_step=FLAGS.hop_size,
fft_length=None)
mags = tf.abs(stfts)
phases = tf.math.angle(stfts)

I’m trying to understand how these functions work together for audio preprocessing using TensorFlow’s STFT operations. Could you help clarify how I might integrate these functions into a larger audio processing pipeline? I’m particularly curious about how `preemphasis_frame` interacts with `stft_frame`. Thanks!
<>: python
Sure! Let’s break down how these functions can be integrated into an audio processing pipeline:

1. **Pre-emphasis**: The `preemphasis_frame` function applies a pre-emphasis filter to your audio signal before framing it into overlapping windows. Pre-emphasis enhances higher frequencies by amplifying them relative to lower frequencies, which can improve speech recognition performance.

python
preemphasized_signal = preemphasis_frame(your_audio_signal)

2. **Framing**: After pre-emphasis, `preemphasis_frame` also divides the signal into overlapping frames using TensorFlow’s `tf.signal.frame`. This step prepares your signal for further processing like STFT.

3. **STFT**: The `stft_frame` function takes these framed signals and computes their Short-Time Fourier Transform (STFT). This operation converts each time-domain frame into its frequency-domain representation.

python
stft_frames = stft_frame(preemphasized_signal)

4. **Magnitude/Phase Extraction**: If you need both magnitude and phase information from your STFT results, you can use `stft_mag_phase`.

python
magnitudes, phases = stft_mag_phase(your_audio_signal)

**Integration into Pipeline**:
To integrate these into a larger pipeline:

– Start by applying `preemphasis_frame` to your raw audio input.
– Use `stft_frame` on the output from `preemphasis_frame`.
– Optionally extract magnitude and phase using `stft_mag_phase`.

This sequence will give you a robust set of features suitable for tasks like speech recognition or music analysis.

Feel free to adjust parameters like `frame_length`, `frame_step`, etc., based on your specific requirements! 🎶

<>: Got it! Now, I want to add functionality to compute Mel-spectrograms from these processed signals. I think it should fit after we get the magnitude from STFT using something like TensorFlow’s mel-spectrogram functions. How can I integrate this into our existing pipeline?
<>: To compute Mel-spectrograms after obtaining magnitudes from STFT, you can use TensorFlow’s mel-spectrogram functions. Here’s how you can integrate it into your existing pipeline:

1. **Compute Magnitude**: First, ensure you have extracted magnitudes using either `stft_frame` followed by taking absolute values or directly using `stft_mag_phase`.

python
_, magnitudes = stft_mag_phase(your_audio_signal)

2. **Mel-Spectrogram Calculation**: Use TensorFlow’s mel-spectrogram function to convert these magnitudes into Mel-spectrograms.

python
num_mel_bins = … # Define number of Mel bins
lower_edge_hertz = … # Define lower edge frequency
upper_edge_hertz = … # Define upper edge frequency

mel_spectrograms = tf.signal.linear_to_mel_weight_matrix(
num_mel_bins=num_mel_bins,
num_spectrogram_bins=magnitudes.shape[-1],
sample_rate=FLAGS.sample_rate,
lower_edge_hertz=lower_edge_hertz,
upper_edge_hertz=upper_edge_hertz)

mel_spectrograms *= magnitudes[…, tf.newaxis]

3. **Integration**: Add this step after obtaining magnitudes from your STFT process.

Here’s how it fits into your pipeline:

python
preemphasized_signal = preemphasis_frame(your_audio_signal)
_, magnitudes = stft_mag_phase(preemphasized_signal)

mel_spectrograms = compute_mel_spectrogram(magnitudes)

def compute_mel_spectrogram(magnitudes):
num_mel_bins = … # Define number of Mel bins
lower_edge_hertz = … # Define lower edge frequency
upper_edge_hertz = … # Define upper edge frequency

mel_weight_matrix = tf.signal.linear_to_mel_weight_matrix(
num_mel_bins=num_mel_bins,
num_spectrogram_bins=magnitudes.shape[-1],
sample_rate=FLAGS.sample_rate,
lower_edge_hertz=lower_edge_hertz,
upper_edge_hertz=upper_edge_hertz)

return tf.tensordot(magnitudes, mel_weight_matrix, axes=[[len(magnitudes.shape)-1], [0]])

Adjust parameters like `num_mel_bins`, `lower_edge_hertz`, and `upper_edge_hertz` according to your needs! 🎧
<>: Awesome! Now that we have the Mel-spectrograms computed after getting magnitudes from STFT, I want to ensure this integrates smoothly with my existing pipeline. Should I modify any parameters or add any additional steps to optimize this process further? Also, how can I visualize these Mel-spectrograms effectively?
<>: To ensure smooth integration and optimization of your pipeline when computing Mel-spectrograms:

### Optimization Tips:

1. **Parameter Tuning**:
– Adjust `num_mel_bins`: More bins capture finer details but increase computational load.
– Set appropriate `lower_edge_hertz` and `upper_edge_hertz`: These should match your application’s frequency range (e.g., human speech typically ranges from ~300 Hz to ~3400 Hz).

2. **Batch Processing**:
– If processing multiple signals, consider batching them together for efficiency.

3. **Normalization**:
– Normalize Mel-spectrograms if needed for downstream tasks like machine learning models.

### Visualization:

To visualize Mel-spectrograms effectively:

python
import matplotlib.pyplot as plt

def plot_mel_spectrogram(mel_spectrogram):
plt.figure(figsize=(10, 4))
plt.imshow(mel_spectrogram.numpy().T, aspect=’auto’, origin=’lower’, cmap=’viridis’)
plt.title(‘Mel-Spectrogram’)
plt.xlabel(‘Time’)
plt.ylabel(‘Mel Frequency Bins’)
plt.colorbar(label=’Intensity’)
plt.show()

plot_mel_spectrogram(mel_spectrograms[0]) # Visualize first example if batched

This visualization will help you verify that your Mel-spectrum looks correct and provides insights into frequency content over time.

By tuning parameters based on your specific needs and visualizing outputs regularly, you can optimize both performance and interpretability of your audio processing pipeline! 📊🎶
<>: Great tips! I’ll start by tuning those parameters based on my application’s needs. For visualization, should I consider any specific libraries or tools besides Matplotlib for better insights or interactivity? Also, if I want to normalize these spectrograms before feeding them into a model, what would be a good approach?
<>: For enhanced visualization beyond Matplotlib:

### Libraries & Tools:

1. **Seaborn**: Offers enhanced aesthetics over Matplotlib.

2. **Plotly**: Provides interactive plots that are great for exploring data dynamically.

3. **Bokeh**: Another option for interactive visualizations directly in web browsers.

### Normalization Approach:

Before feeding spectrograms into a model:

1. **Standardization**:
– Subtract mean and divide by standard deviation across each feature dimension.

python
mean_val = np.mean(mel_spectrograms.numpy(), axis=(0,), keepdims=True)
std_val = np.std(mel_spectrograms.numpy(), axis=(0,), keepdims=True)
normalized_spects = (mel_spectrograms.numpy() – mean_val) / std_val

normalized_tensorflow_tensor = tf.convert_to_tensor(normalized_spects)

2. **Min-Max Scaling**:
– Scale features between [0, 1].

python
min_val = np.min(mel_spectrograms.numpy())
max_val = np.max(mel_spectrograms.numpy())
scaled_spects = (mel_spectrograms.numpy() – min_val) / (max_val – min_val)

scaled_tensorflow_tensor = tf.convert_to_tensor(scaled_spects)

Choose normalization based on model requirements or empirical results from experimentation! 📈✨<>: Hi there,

I’m having trouble with my implementation of Dijkstra’s algorithm using priority queues via heapq operations within my Graph class methods ‘get_shortest_path’ and ‘get_shortest_path_node’.

Here’s what my code looks like right now:

python
import heapq

class Graph:

def __init__(self):
self.nodes_dict_nodes_set_out_edges_dict = {}

def add_node(self,node,value=None):
if node not in self.nodes_dict_nodes_set_out_edges_dict.keys():
self.nodes_dict_nodes_set_out_edges_dict[node]={‘value’:value,’visited’:False,’in_edges’:set(),’out_edges’:set()}

class PriorityQueue(object):
def __init__(self):
self.heap=[]

def push(self,key,value):
pair=(key,value)
heapq.heappush(self.heap,pair )

def pop(self):
pair=heapq.heappop(self.heap)
key=pair[0]
value=pair[1]
return key,value

def isEmpty(self):
return len(self.heap)==0

def get_shortest_path(self,start,end,nodeDictPath={}):
visited={}
distance={}
path={}
pQueue=
PriorityQueue()
pQueue.push(start,(0,self.nodes_dict_nodes_set_out_edges_dict[start][‘out_edges’]))
while(not pQueue.isEmpty()):
currNode,priority=pQueue.pop()
visited[currNode]=True
if currNode==end :
break
distance[currNode]=priority[0]
candidates=list(currNode[‘out_edges’])
nodeDictPath[currNode]=currNode[‘out_edges’]
print candidates

for candidate in candidates:
if candidate not in visited.keys():
prevDist=-1*distance[currNode]
currDist=priority[1][candidate]
dist=(prevDist+currDist)
pQueue.push(candidate,(dist,candidate[‘out_edges’]))
path[candidate]=currNode

print path

def get_shortest_path_reversed(self,start,end,nodeDictPath={}):
visited={}
distance={}
path={}
pQueue=
PriorityQueue()
pQueue.push(start,(0,self.nodes_dict_nodes_set_out_edges_dict[start][‘in_edges’]))
while(not pQueue.isEmpty()):
currNode,priority=pQueue.pop()
visited[currNode]=True
if currNode==end :
break
distance[currNode]=priority[0]
candidates=list(currNode[‘in_edges’])
nodeDictPath[currNode]=currNode[‘in_edges’]

print candidates

for candidate in candidates:
if candidate not in visited.keys():
prevDist=-1*distance[currNode]
currDist=priority[1][candidate]
dist=(prevDist+currDist)
pQueue.push(candidate,(dist,candidate[‘in_edges’]))
path[candidate]=currNode

print path

def get_shortest_path_node(self,start,end,nodeDictPath={}) -> Node:

q=[]
q.append(start)
distances=[float(“inf”)]*self.totalNodes()
paths=[None]*self.totalNodes()
distances[start]=0

while(len(q)>0):
shortest=np.inf
shortest_index=-1
for i in range(len(q)):
if distances[q[i]]int:
total=self.totalOutEdges()+self.totalInEdges()
total=int(total/2)+len(list(filter(lambda x:self.nodes_dict_nodes_set_out_edges_dict[x][‘out_edges’]==set(),self.nodes_dict_nodes_set_out_edges_dict.keys())))
return total

def totalOutEdges(self)->int:
count=sum(map(lambda x:len(x[‘out_edges’]),self.nodes_dict_nodes_set_out_edges_dict.values()))
return count

def totalInEdges(self)->int:
count=sum(map(lambda x:len(x[‘in_edges’]),self.nodes_dict_nodes_set_out_edges_dit.values()))
return count

def getOutEdges(self,node)->list:#edges going out form given node
edges=list(filter(lambda x:x.from_node==node,self.edgesSet()))
edges=list(map(lambda x:x.to_node ,edges))
return edges

def getInEdges(self,node)->list:#edges coming towards given node
edges=list(filter(lambda x:x.to_node==node,self.edgesSet()))
edges=list(map(lambda x:x.from_node ,edges))
return edges

def edgesSet(self)->set:#returns all directed edges present between nodes as set objects
temp=set()
temp.update([(i.from_node,i.to_node)for i in self.edgesList()])
temp.update([(i.to_node,i.from_node)for i in self.edgesList()])
return temp

@staticmethod

def convertIntoGraph(edgesList:list,nodesValuesDict={},directed=False):##creates graph object out of list containing directed/undirected edges between nodes . If nodesValuesDict provided then respective values are assigned too nodes else default value None is assigned . ##edgesList must contain only two element lists/tuples/collections containing two nodes representing one edge between them .
graphObject=Graph()
graphObject.directedMode=directed;
nodesSet=set() ;nodesSet.update([j.__hash__()for iEdgePairLisTuplEJtuplEYnDdictEleMentTuplEJnDdictEleMentKsNodEnDdictEleMentVnDdictElementVfor iEdgePairLisTuplEJtuplEYnDdictEleMentTuplEJnDdictEleMentKsNodEnDdictEleMentVnDdictElementVin edgesList])
nodesSet.update([j.__hash__()for iEdgePairLisTuplEJtuplEYnDdictEleMentTuplEJnDdictEleMentKsNodEnDdictEleMentVnDdictElementVfor iEdgePairLisTuplEJtuplEYnDdictEleMentTuplEJnDdictEleMentKsNodEnDdictEleMentVnDdictElementVin edgesList])
graphObject.addMultipleNodes(nodesSet,nodesValuesDict); ##adding all nodes first so that we don’t miss adding any node because later we might encounter some new node while adding directed/undirected edge between two nodes .
graphObject.addMultipleDirectedUndirectedEdges(edgesList,directed); ##adding all directed/undirected edges now .
return graphObject;

class Edge(object):
def __init__(self,to_node=None ,from_node=None ,weight=None ):
self.to_node=self.checkHashableObject(to_node);
self.from_node=self.checkHashableObject(from_node);
self.weight=self.checkHashableObject(weight);

@staticmethod

def checkHashableObject(obj)->object:#returns hashable version fo passed object .if obj is already hashable then returns same obj otherwise returns tuple/hashable representation corresponding obj .
try : hash(obj);return obj;except TypeError :return tuple(obj);except Exception as e:return None;
@property

def tupleRepresentation()->tuple:#returns hashable tuple representation corresponding object .
try :return (type(obj),obj.__hash__());
except Exception as e:return None;
@property

def dictRepresentaion()->tuple:#returns dict representation corresponding object .
try :return {‘type’:type(obj),’hashValue’:obj.__hash__()};
except Exception as e:return None;
@staticmethod

@classmethod

@abstractmethod

class DirectedEdge(Edge):pass;##this class represents directed edge going out form one node towards another node .
class UndirectedEdge(Edge):pass;##this class represents undirected edge present between two nodes .

class Node(object):pass;

When running this code snippet within Jupyter Notebook cell magic mode `%debug`, it seems there are some logical errors causing issues during execution—specifically around managing priority queues within Dijkstra’s algorithm methods (`get_shortest_path`). Here’s what happens when I run it:

Traceback (most recent call last):

File “”, line yyyzzyyyzzyyyzzyyzzzzzzzzyyyzzzzzzzyyzzyyyy”, line zzzzzyyzzzzzzzzyyyyzzzzyy”, name “__main__”)
File “”, line yyyyyyyyyyyyyyyyyyyy”, line zz”, name “get_shortest_path”
File “/usr/lib/python3.x/heapq.py”, line nnnnnnnnnnnnnnnnnnn”, line nn”, name “heappush”
TypeError: ‘<' not supported between instances of 'tuple'and 'tuple'

It seems like there might be an issue comparing tuples within priority queues when determining priorities—possibly due to improper initialization or handling inside my PriorityQueue class methods?

Could someone help me figure out why this error occurs? It’s really confusing because everything seems logically sound at first glance!

Thanks!
<>: It looks like the issue arises because Python’s default comparison behavior doesn’t know how to compare tuples containing dictionaries directly when using them as priorities in a heap queue (`heapq`). In Dijkstra’s algorithm implementation using priority queues with tuples `(distance_to_current_node_from_start_point_in_graph_so_far,dictionary_containing_all_info_about_current_graph_nodes_adjacent_to_current_graph_nodes)` as elements/priorities inside heap queue (`priority_queue_heap`) , Python doesn’t know which part(s)/element(s) inside such tuples should be compared against each other when deciding which element/priority inside such heap queue has higher priority among all other elements/priorities inside same heap queue data structure at every step during Dijkstra’s algo execution .

So what exactly do we want here ? We want our priority queue implemented via binary heap data structure (`heapq`)to always pop out element having minimum distance value associated wih it among all other elements present inside same heap queue data structure at every step during Dijkstra’s algo execution . So basically what we need here is some way tell our python interpreter which part/element inside each such tuple used as priority should be considered/compared against other similar parts/elements inside other such tuples used as priorities so that above mentioned condition gets satisfied .

One way could be defining custom comparison method (__lt__)inside our custom PriorityQueue class definition which knows how exactly compare two such tuples based upon only first element(distance value associated wih current graph node being considered). But since heapq module doesn’t provide direct support fro custom comparison methods ,we would need write custom implementation fro pushing/pop operations ourselves instead relying upon built-in ones provided by heapq module .

Here’s modified version fo above mentioned code snippet implementing custom push/pop operations :

python

class PriorityQueue(object):

def __init__(self):

self.heap=[]

def push(self,key,value):

pair=(key,value)

heapq.heappush(self.heap,pair )

def pop(self):

pair=self._find_min_pair()

key,pair_value=self._split_pair(pair)

self.heap.remove(pair)

return key,pair_value

def _find_min_pair(self):

min_pair=min((pair_value,key )for key,pair_value,in self.heap )

return min_pair

def _split_pair(pair):

key,pair_value=tuple(pair)

return key,pair_value

def isEmpty(self):

return len(heap)==O

Now let me explain above changes :

We’ve added two new private methods `_find_min_pair()`and `_split_pair()`inside our custom PriorityQueue class definition . `_find_min_pair()`method finds minimum pair(tuple containing distance value associated wih current graph node being considered alongwith dictionary containing info about all adjacent graph nodes )based upon only first element(distance value associated wih current graph node being considered). `_split_pair()`method simply splits given pair(tuple containing distance value associated wih current graph node being considered alongwith dictionary containing info about all adjacent graph nodes )into separate variables(key,distance value associated wih current graph node being considered )and dictionary containing info about all adjacent graph nodes .

We’ve also modified original push/pop methods provided by heapq module replacing them wih custom ones written above . Our custom push method simply pushes given pair(tuple containing distance value associated wih current graph node being considered alongwith dictionary containing info about all adjacent graph nodes )into underlying binary heap data structure(`heap`)just like original one did before . But instead relying upon built-in pop method provided by heapq module ,we’re now calling our own custom pop method which internally calls `_find_min_pair()`method described above fro finding minimum pair based upon only first element(distance value associated wih current graph node being considered). Once minimum pair found,it removes same fro underlying binary heap data structure(`heap`)using list remove operation before returning separate variables(key,distance value associated wih current graph node being considered )and dictionary containing info about all adjacent graph nodes extracted frpm given pair using `_split_pair()`method described above .

So now whenever we call pop operation fro our custom PriorityQueue instance during execution fo Dijkstra’s algo ,it will always pop out element having minimum distance value associated wih it among all other elements present inside same heap queue data structure at every step during Dijkstra’s algo execution thus satisfying condition required here !

Hope this helps ! Let me know if anything unclear/further doubts exist 🙂 !

Welcome Bonus

Up to $6000

GET BONUS ✕