Regression Analysis of the NPLD Stratigraphy

CMPS 6160 Final Tutorial - Alan Braeley

Project website:

https://abraeley.github.io/

Project repository:

https://github.com/abraeley/abraeley.github.io

Project data:

https://github.com/abraeley/abraeley.github.io/data

Raw SHARAD data:

https://pds-geosciences.wustl.edu/missions/mro/sharad.htm

Background: The north and south poles of Mars are composed primarily of a combination of water ice, dust, and in the south, carbon dioxide. These polar ice caps are often referred to as the north and south polar layered deposits (NPLD/SPLD). The PLD are thought to record up to approximately 5 Mya of climate history on Mars, trapped in the stratigraphy of the ice. In order to study and learn from this geological history, we must first be able to properly interpret the data. When the dielectric properties of a layer interface with another, a radar reflection (called a "reflector") may be generated. The radar data that is recieved back takes the form of a cross-section of the ice cap, from the surface to the bedrock below the ice:

The brightness of each reflector tells us something about the material composition of the layer, while the time it takes to receive a reflection back tells us the depth of the reflector (since radar moves consistently at the speed of light). A reflector's brightness is determined by the difference between the dielectric properties of two layers. The instrument that is used to collect these radargrams is called SHARAD (shallow radar), a radar sounder aboard the Mars Reconnaissance Orbiter. SHARAD emits a 15-25 MHz radar signal into the ice caps in order to see into the interior structure beneath the surface of the ice.

Cutting into the NPLD are troughs inside which exposed stratigraphic layerse are visible in optical light:

It has been thought that these stratigraphic layers correspond in a one-to-one basis with the reflectors seen in SHARAD radargrams.

Motivation: A collaborator on my research (Dr. Bruce Campbell) split the radar data into two sub-bands (called split chirp data): a low frequency sub band of 15-20 MHz, and a high-frequency band of 20-25 MHz:

From this it is clear that there are differences between the high and low frequency radar data. Implicit therein is that at least some of the PLD is sensitive to the frequency of the radar. This resolution-sensitive is telling, as radar is already some distance from the optical part of the electromagnetic spectrum. It is therefore unlikely that one can assume a one-to-one relationship between images in radio-wavelength data with those seen in optical data. The reflectors in the PLD is therefore not the same as a stratigraphic layer, as seen in photographs.

Model-Generated Data:

I will be using two datasets: one that I generate, and one that comes from SHARAD (shallow radar) sounder data from the Mars Reconnaissance Orbiter.

The first dataset is to be created by using the 1-dimensional model developed by Sam Courville from the SHARAD team. This model takes in several "layer property" parameters (as opposed to processing parameters):

As shown above, number of layers (n), thicknesses of the layers (m) (the final layer is considered unbounded so the thickness is effectively infinite and does not count), the dielectric constants of the layers, and the loss tangents of the layers are all input parameters. The other parameters vary the way the model processes the layer property parameters. For example, rather than using the SHARAD instrument frequency band (15-25 MHz), a sub band can be used (i.e. 15-20 MHz), or a different frequency range can be selected altogether.

The model outputs a dataset contained in a csv file, with time (in microseconds), power (in dB) and amplitude columns. It also plots the power as a function of time, with power on the x-axis:

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import math

# Reading in the csv files
low3df = pd.read_csv('data/Intersection_3/Model3_L_output_data.csv', sep=",")
high3df = pd.read_csv('data/Intersection_3/Model3_H_output_data.csv', sep=",")
low3df.head(10)

	Time (s)	power (dB)	amplitude (real)	amplitude (imag)
0	-0.000043	-57.853135	-3.892997e-09	-3.692354e-10
1	-0.000042	-57.779216	3.897481e-09	6.032395e-10
2	-0.000042	-57.313703	-4.094372e-09	-7.417902e-10
3	-0.000042	-56.853206	4.335889e-09	6.715193e-10
4	-0.000042	-56.701135	-4.444132e-09	-4.319517e-10
5	-0.000042	-56.957712	4.331215e-09	1.836783e-10
6	-0.000042	-57.521867	-4.061128e-09	-1.051084e-10
7	-0.000042	-58.031659	3.821435e-09	2.693440e-10
8	-0.000042	-57.999919	-3.802190e-09	-5.717598e-10
9	-0.000042	-57.404672	4.042892e-09	7.811902e-10

# Creating three figures, a high frequency,  low frequency, and normalized frequencies plot
fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(12,10))
fig.suptitle('Model-Generated Data (Low vs High Frequency)', fontsize=16)

lowExample = low3df.plot(ax=axes[0], x='power (dB)', y='Time (s)', xlabel="Power (dB)", ylabel="Time (s)", legend=False)
lowExample.set_ylim(0, 0.0000205)
lowExample.set_xlim(-50, 0)
lowExample.invert_yaxis()
lowExample.set_title("Low Freq (15-20 MHz)")

normdf = high3df
normdf["Normalized (High/Low)"] = high3df["power (dB)"]/low3df["power (dB)"]
normalizedPlot = normdf.plot(ax=axes[1], x="Normalized (High/Low)", y='Time (s)', xlabel="High freq/Low freq", legend=False)
normalizedPlot.set_ylim(0, 0.0000205)
normalizedPlot.set_xlim(0.5, 1.5)
normalizedPlot.invert_yaxis()
normalizedPlot.axvline(1)
normalizedPlot.set_title("Normalized Power")

highExample = high3df.plot(ax=axes[2], x='power (dB)', y='Time (s)', xlabel="Power (dB)", legend=False)
highExample.set_ylim(0, 0.0000205)
highExample.set_xlim(-50, 0)
highExample.invert_yaxis()
highExample.set_title("High Freq (20-25 MHz)")

Text(0.5, 1.0, 'High Freq (20-25 MHz)')

Shown above are two such model-generated plots (and a normalized figure too). Made by manually entering the layer parameters in the 1D Radar Simulator model and changing the frequency bands into a low and high frequency (15-20 MHz, and 20-25 MHz respectively). It should be noted that time is a stand-in for distance/depth beneath the surface of the ice cap, as the speed of light is a constant. The following formula can be used to convert the time to distance:

$ d = \frac{tc}{2\sqrt{\epsilon}} $

Where $d$ is distance, $t$ is time it takes to receive the radar return and $\epsilon$ is the dielectric constant.

The power vs time figures showcase that the reflectors are sensitive to radar frequency (note that although the normalized power subplot is approximately centered around one, there are power peaks that appear uniquely in the low and high frequency figures (at the same depth beneath the surface ice). The normalized plot shows that there are significant, and extensive, differences between the split data, implying sensitivity to the changing frequency bands.

SHARAD Split Chirp Data

The raw SHARAD data comes in the form of a radargram, which is recorded in a single track as the MRO spacecraft orbits above Mars:

All radargrams are 3600 pixels tall (there are 3600 pixel rows comprising the image). In order to replicate the data produced by the SHARAD model, a one-pixel-wide, vertical column of power values can be taken at each pixel from spanning the height of the radargram. By then cutting the data to the surface and basal reflectors in the figure a power versus time figure will be produced out of the split chirp data. Each pixel down is equivalent to 0.0375 microseconds of time (and therefore has a corresponding distance value too).

# Setting some basic parameters (selecting where on the rows I want to an)
timePixel = 0
columnNumber = 1110

# Reading in the SHARAD split chirp data
with open('data/s_03196501/S_03196501_L_RGRAM.IMG', mode='r') as f:
 data = np.fromfile(f,dtype=np.float32)
 #datatest = np.matrix(data)

radargram = data.reshape(3600, -1)


powerColumn1 = []
time = []

columnNumber -= 1
#Python starts iterating at zero so the last column is columnNumber - 1

for pixelRow in range(0,len(radargram)):
    #print("pixelRow: "+pixelRow+" Raw power: "+)
    
    '''
    Iterating straight down at a given column
    Using the center column value as a pixel value reference, 
    take the left and right 10 columns-worth of data. In order to do this 
    find the pixel value in the column to the left and right of the center 
    column that most matches that of the center reference pixel value. 
    By doing this I will be able to follow the path of each continuous lateral
    reflector as I take averages downward.
    '''
    time.append(timePixel)
    
    # time per pixel
    timePixel+=0.0375
    
    leftNum = columnNumber - 1
    leftNum2 = columnNumber - 2
    leftNum3 = columnNumber - 3
    rightNum = columnNumber + 1
    rightNum2 = columnNumber + 2
    rightNum3 = columnNumber + 3
        
    rowLeft3 = radargram[pixelRow][leftNum3]
    rowLeft2 = radargram[pixelRow][leftNum2]
    rowLeft = radargram[pixelRow][leftNum]
    rowCenter = radargram[pixelRow][columnNumber]
    rowRight = radargram[pixelRow][rightNum]
    rowRight2 = radargram[pixelRow][rightNum2]
    rowRight3 = radargram[pixelRow][rightNum3]

    powerRow = [rowLeft,rowLeft2,rowLeft3,rowCenter,rowRight,rowRight2,rowRight3]

    powerRow = [10*math.log10(x) for x in powerRow]
    powerRow = sum(powerRow)/len(powerRow) #Average of columns
    powerColumn1.append(powerRow)
    
# Top of surface reflector  
beginning = 2377

# Top of basal reflector
end = 2897

time = time[beginning:end]
powerColumn1 = powerColumn1[beginning:end]

# Reading in the high frequency data
timePixel = 0   

columnNumber = 1110

with open('data/s_03196501/S_03196501_H_RGRAM.IMG', mode='r') as f:
 data = np.fromfile(f,dtype=np.float32)
radargram = data.reshape(3600, -1)

powerColumn2 = []
time = []

columnNumber -= 1
#Python starts iterating at zero so the last column is columnNumber - 1

for pixelRow in range(0,len(radargram)):
    
    '''
    Iterating straight down at a given column
    Using the center column value as a pixel value reference, 
    take the left and right 10 columns-worth of data. In order to do this 
    find the pixel value in the column to the left and right of the center 
    column that most matches that of the center reference pixel value. 
    By doing this I will be able to follow the path of each continuous lateral
    reflector as I take averages downward.
    '''
    time.append(timePixel)

    timePixel+=0.0375
    
    leftNum = columnNumber - 1
    leftNum2 = columnNumber - 2
    leftNum3 = columnNumber - 3
    rightNum = columnNumber + 1
    rightNum2 = columnNumber + 2
    rightNum3 = columnNumber + 3
    
    rowLeft3 = radargram[pixelRow][leftNum3]
    rowLeft2 = radargram[pixelRow][leftNum2]
    rowLeft = radargram[pixelRow][leftNum]
    rowCenter = radargram[pixelRow][columnNumber]
    rowRight = radargram[pixelRow][rightNum]
    rowRight2 = radargram[pixelRow][rightNum2]
    rowRight3 = radargram[pixelRow][rightNum3]
    
    powerRow = [rowLeft,rowLeft2,rowLeft3,rowCenter,rowRight,rowRight2,rowRight3]

    powerRow = [10*math.log10(x) for x in powerRow]
    powerRow = sum(powerRow)/len(powerRow) #Average of columns
    powerColumn2.append(powerRow)
    
# Top of surface reflector  
beginning = 2383

# Top of basal reflector in the radargram
end = 2903

time = time[beginning:end]
powerColumn2 = powerColumn2[beginning:end]

# Plotting the power versus time figures for both high and low frequency data
fig, axs = plt.subplots(figsize=(6,18)) 
plt.plot(powerColumn2,time)  
plt.plot(powerColumn1,time, color='red') 
plt.title("Track 03246101", fontsize=28)
plt.legend(["S_03246101_H", "S_03246101_L"], loc=4, fontsize=18)
plt.xlabel('Power (dB)', fontsize=24)  
plt.ylabel('Time (\u03BCs)', fontsize=24)
axs.invert_yaxis()
plt.show()

Plan and question(s) to be answered: My goal is to leverage the one-dimensional model created by the SHARAD team (introduced below) in order to determine what of the model input parameters (dielectric constant, layer thickness, etc.) has what sort of impact on the reflectors as a function of frequency. After that, my goal will be to apply this knowledge to the split chirp SHARAD data in order to explore the interior stratigraphy, the geospatial distribution of dielectric properties and to hopefully serve as a stepping stone forward in our ability to further unlock the recent martian climate history.

To accomplish this I will write a python script to automate the varying of input parameters, and the running of the SHARAD model. With a large dataset outputted by the model, I will then use the various input parameters for each respective model dataset in order to train a neural network, where the model input parameters (and their respective models) will become the various input features for the neural network.

Neural network for regression:

Input 1: Vertical column of pixels from the radargram

Output 1: Number of layers (n)

Output 2: Thicknesses of n-1 layers (m)

Output 3: Real relative dielectric constants of n layers

At this point I will apply the neural network to the actual SHARAD split chirp data, hopefully revealing a new understanding of how stratigraphy and material composition impact reflectors in the SHARAD split chirp data.

The neural network I will be using is the "Multilayer Perceptron Classifier" (MPC) tool from Scikit Learn.

In order to properly generate the training data needed to feed into the MPC tool, I downloaded the 1D model written by the NASA SHARAD team:

ls SHARAD_1D_Model/*.py

SHARAD_1D_Model/radar_FM1D_refMethod.py*

This python script generates the the .csv files that contain modelled data analogous to the vertical pixel column of power values taken from the radargram data that I plotted above as "Track 03246101". In order to run it however, I need to generate the input parameters to feed into the model (shown above in the "1D Radar Simulator" image).

Since this is a tedious task to do manually, I wrote a script to run the 1D python model locally:

# Generate the parameters


def generateModels(depth = 2000, modelCount = 1, iterationStepSize = 1, startingLayerSize = 1, freqBand = 0, singleModel = 1):
    # Surface to basal reflector depth (meters)
    
    '''
    Depth is kept consistent throughout the model generation process (in meters). 
    Layer thicknesses are varied across a consistent total depth.
    
    modelCount is a parameter used to assign iteration numbers to model
    names that have been generated by this function.
    
    The iterationStepSize is how large the intervals are in layer size variation
    increases between intervals (in meters).
    
    startingLayerSize is the size of the first layer (in meters).
    
    freqBand = 0 for combined total frequency band (15-25 MHz). Setting it to 1 runs the low
    frequency band (15-20 MHz), while setting it to 2 runs the high frequency band (20-25 MHz).
    
    To generate only a single model, leave the singleModel parameter = 1. Setting it to any other
    value will set the function up to generate numerous models.
    '''
    import numpy as np
    
    if freqBand == 0:
        # Combined 15-25 MHz model
        freqBand = '15e6 25e6'
        freqBandName = "_Full"
        
    elif freqBand == 1:
        # Low freq 15-20 MHz model
        freqBand = '15e6 20e6'
        freqBandName = "_L"
        
    elif freqBand == 2:
        # High freq 20-25 MHz model
        freqBand = '20e6 25e6'
        freqBandName = "_H"

    # Number of layers
    for layerThickness in np.arange(startingLayerSize, depth, iterationStepSize):
        #if depth % layerThickness != 0.0:
           # continue # The layers must be evenly divisible into the depth
            # This allows for a consistent depth across models
        thicknessList = []
        iterationLayerList = [] # Thickness list for *current* iteration
        dielectricList = []
        lossTangentList = []
        numberOfLayers = depth // layerThickness # Number of layers that cleanly divides into depth
        thicknessList.append(layerThickness) # This will be what is iterated over to generate each model         

        for i in range(int(numberOfLayers)):
            iterationLayerList.append(str(layerThickness))

            # Note, the dielectric constant NEEDS to be changed between layers to generate a reflection
            if (i%2) != 0:
                # Hard coding average dielectric value from Grima et al. 2009 --> 3.10
                dielectricList.append(str(3.4))
                # Hard coding average loss tangent value from Grima et al. 2009 --> 0.0026
                lossTangentList.append(str(0.0026))
            else:
                 # Hard coding average dielectric value from Grima et al. 2009 --> 3.10
                dielectricList.append(str(2.8))
                # Hard coding average loss tangent value from Grima et al. 2009 --> 0.0026
                lossTangentList.append(str(0.0026))

        # Generate the model
        with open('model_'+str(modelCount)+freqBandName+'.txt', 'w') as f:
            f.write('### 1D Radar Sounding Forward Model file')
            f.write('\n')
            f.write('# Observation height/altitude above ground (meters)')
            f.write('\n')
            f.write('300e3')
            f.write('\n')
            f.write('# Approximate noise floor value in dB (ignored if less than -100dB)')
            f.write('\n')
            f.write('-101')
            f.write('\n')
            f.write('# Number of layers, n')
            f.write('\n')
            f.write(str(int(numberOfLayers)))
            f.write('\n')
            f.write('# Layer thicknesses (put n-1 values, last layer assumed to be infinite)')
            f.write('\n')
            f.write(" ".join(iterationLayerList))
            f.write('\n')
            f.write('# Real relative dielectric permittivity')
            f.write('\n')
            f.write(" ".join(dielectricList))
            f.write('\n')
            f.write('# Do you want to use conductivity (1) or loss tangent (0)?')
            f.write('\n')
            f.write('0')
            f.write('\n')
            f.write('# Loss tangent for each layer, or conductivity')
            f.write('\n')
            f.write(" ".join(lossTangentList))
            f.write('\n')
            f.write('# directory/file of time domain source pulse')
            f.write('\n')
            f.write('Sharad_Ideal_sourcePulse.csv')
            f.write('\n')
            f.write('# directory/file of frequency domain matched filter (or "none")')
            f.write('\n')
            f.write('Sharad_Ideal_matchedFilter.csv')
            f.write('\n')
            f.write('# Kaiser window degree (0 for no windowing)')
            f.write('\n')
            f.write('6')
            f.write('\n')
            f.write('# Window frequencies')
            f.write('\n')
            f.write(freqBand)
        if singleModel == 1:
            break
        else:
            pass
        modelCount+=1
        
generateModels(2000, 1, 1, 1, 2, 1)

cd SHARAD_1D_Model/

/home/abraeley/Downloads/abraeley.github.io-main/SHARAD_1D_Model

ls

model_10000_H.txt               model_1600_L_output_data.csv
model_10000_L.txt               model_1600_L_output_figure.png
model_10000.txt                 model_1600_model.csv
model_1600_H_model.csv          model_1600_output_data.csv
model_1600_H_output_data.csv    model_1600_output_figure.png
model_1600_H_output_figure.png  test/
model_1600_L_model.csv

In the interest of preventing a mess, I will abstain from running the above cell here again, as it would generate many models. I ran this on my computer and created several thousand model .txt files. Here is an example of one of the model files:

cat SHARAD_1D_Model/model_4626.txt

### 1D Radar Sounding Forward Model file
# Observation height/altitude above ground (meters)
300e3
# Approximate noise floor value in dB (ignored if less than -100dB)
-101
# Number of layers, n
43
# Layer thicknesses (put n-1 values, last layer assumed to be infinite)
46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26 46.26
# Real relative dielectric permittivity
2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8 3.4 2.8
# Do you want to use conductivity (1) or loss tangent (0)?
0
# Loss tangent for each layer, or conductivity
0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026 0.0026
# directory/file of time domain source pulse
Sharad_Ideal_sourcePulse.csv
# directory/file of frequency domain matched filter (or "none")
Sharad_Ideal_matchedFilter.csv
# Kaiser window degree (0 for no windowing)
6
# Window frequencies
15e6 20e6

Note that this model file is the raw text to feed into the SHARAD 1D simulator, typically it is rendered in a GUI. The GUI image is what you see in the "1D Radar Simulator" image. Once my script generated several thousand models, I needed to write a shellscript to actually run the 1D radar simulator pythone script for each model. As there are thousands I wanted to generate models, the shellscript was necessary:

cat SHARAD_1D_Model/runModels.sh

#!/bin/bash

for f in *.txt; do python radar_FM1D_refMethod.py ${f}; done;

For the sake of simplicity, I am starting off by varying only the number of layers/layer thicknesses, ignoring other possible ways to vary the data like the two frequency subbands, as well as variations of the dielectric constants. I hold the total depth from the surface of the ice, to the base of the ice the same (2000 meters). I vary the dielectric constant from 3.4 to 2.8, which gives an average of 3.1, and a loss tangent of 2.6 (Grima et al. 2009). If I didn't vary the dielectric constant at all, no reflections would be generated.

After running the 1D simulator with my models, I was able to generate (as .csv files) my model-generated data:

ls data/*.csv

data/model_1000_output_data.csv  data/model_2000_output_data.csv
data/model_1001_output_data.csv  data/model_2001_output_data.csv
data/model_1002_output_data.csv  data/model_2002_output_data.csv
data/model_1003_output_data.csv  data/model_2003_output_data.csv
data/model_1004_output_data.csv  data/model_2004_output_data.csv
data/model_1005_output_data.csv  data/model_2005_output_data.csv
data/model_1006_output_data.csv  data/model_2006_output_data.csv
data/model_1007_output_data.csv  data/model_2007_output_data.csv
data/model_1008_output_data.csv  data/model_2008_output_data.csv
data/model_1009_output_data.csv  data/model_2009_output_data.csv
data/model_1010_output_data.csv  data/model_2010_output_data.csv
data/model_1011_output_data.csv  data/model_2011_output_data.csv
data/model_1012_output_data.csv  data/model_2012_output_data.csv
data/model_1013_output_data.csv  data/model_2013_output_data.csv
data/model_1014_output_data.csv  data/model_2014_output_data.csv
data/model_1015_output_data.csv  data/model_2015_output_data.csv
data/model_1016_output_data.csv  data/model_2016_output_data.csv
data/model_1017_output_data.csv  data/model_2017_output_data.csv
data/model_1018_output_data.csv  data/model_2018_output_data.csv
data/model_1019_output_data.csv  data/model_2019_output_data.csv
data/model_1020_output_data.csv  data/model_2020_output_data.csv
data/model_1021_output_data.csv  data/model_2021_output_data.csv
data/model_1022_output_data.csv  data/model_2022_output_data.csv
data/model_1023_output_data.csv  data/model_2023_output_data.csv
data/model_1024_output_data.csv  data/model_2024_output_data.csv
data/model_1025_output_data.csv  data/model_2025_output_data.csv
data/model_1026_output_data.csv  data/model_2026_output_data.csv
data/model_1027_output_data.csv  data/model_2027_output_data.csv
data/model_1028_output_data.csv  data/model_2028_output_data.csv
data/model_1029_output_data.csv  data/model_2029_output_data.csv
data/model_1030_output_data.csv  data/model_2030_output_data.csv
data/model_1031_output_data.csv  data/model_2031_output_data.csv
data/model_1032_output_data.csv  data/model_2032_output_data.csv
data/model_1033_output_data.csv  data/model_2033_output_data.csv
data/model_1034_output_data.csv  data/model_2034_output_data.csv
data/model_1035_output_data.csv  data/model_2035_output_data.csv
data/model_1036_output_data.csv  data/model_2036_output_data.csv
data/model_1037_output_data.csv  data/model_2037_output_data.csv
data/model_1038_output_data.csv  data/model_2038_output_data.csv
data/model_1039_output_data.csv  data/model_2039_output_data.csv
data/model_1040_output_data.csv  data/model_2040_output_data.csv
data/model_1041_output_data.csv  data/model_2041_output_data.csv
data/model_1042_output_data.csv  data/model_2042_output_data.csv
data/model_1043_output_data.csv  data/model_2043_output_data.csv
data/model_1044_output_data.csv  data/model_2044_output_data.csv
data/model_1045_output_data.csv  data/model_2045_output_data.csv
data/model_1046_output_data.csv  data/model_2046_output_data.csv
data/model_1047_output_data.csv  data/model_2047_output_data.csv
data/model_1048_output_data.csv  data/model_2048_output_data.csv
data/model_1049_output_data.csv  data/model_2049_output_data.csv
data/model_1050_output_data.csv  data/model_2050_output_data.csv
data/model_1051_output_data.csv  data/model_2051_output_data.csv
data/model_1052_output_data.csv  data/model_2052_output_data.csv
data/model_1053_output_data.csv  data/model_2053_output_data.csv
data/model_1054_output_data.csv  data/model_2054_output_data.csv
data/model_1055_output_data.csv  data/model_2055_output_data.csv
data/model_1056_output_data.csv  data/model_2056_output_data.csv
data/model_1057_output_data.csv  data/model_2057_output_data.csv
data/model_1058_output_data.csv  data/model_2058_output_data.csv
data/model_1059_output_data.csv  data/model_2059_output_data.csv
data/model_1060_output_data.csv  data/model_2060_output_data.csv
data/model_1061_output_data.csv  data/model_2061_output_data.csv
data/model_1062_output_data.csv  data/model_2062_output_data.csv
data/model_1063_output_data.csv  data/model_2063_output_data.csv
data/model_1064_output_data.csv  data/model_2064_output_data.csv
data/model_1065_output_data.csv  data/model_2065_output_data.csv
data/model_1066_output_data.csv  data/model_2066_output_data.csv
data/model_1067_output_data.csv  data/model_2067_output_data.csv
data/model_1068_output_data.csv  data/model_2068_output_data.csv
data/model_1069_output_data.csv  data/model_2069_output_data.csv
data/model_1070_output_data.csv  data/model_2070_output_data.csv
data/model_1071_output_data.csv  data/model_2071_output_data.csv
data/model_1072_output_data.csv  data/model_2072_output_data.csv
data/model_1073_output_data.csv  data/model_2073_output_data.csv
data/model_1074_output_data.csv  data/model_2074_output_data.csv
data/model_1075_output_data.csv  data/model_2075_output_data.csv
data/model_1076_output_data.csv  data/model_2076_output_data.csv
data/model_1077_output_data.csv  data/model_2077_output_data.csv
data/model_1078_output_data.csv  data/model_2078_output_data.csv
data/model_1079_output_data.csv  data/model_2079_output_data.csv
data/model_1080_output_data.csv  data/model_2080_output_data.csv
data/model_1081_output_data.csv  data/model_2081_output_data.csv
data/model_1082_output_data.csv  data/model_2082_output_data.csv
data/model_1083_output_data.csv  data/model_2083_output_data.csv
data/model_1084_output_data.csv  data/model_2084_output_data.csv
data/model_1085_output_data.csv  data/model_2085_output_data.csv
data/model_1086_output_data.csv  data/model_2086_output_data.csv
data/model_1087_output_data.csv  data/model_2087_output_data.csv
data/model_1088_output_data.csv  data/model_2088_output_data.csv
data/model_1089_output_data.csv  data/model_2089_output_data.csv
data/model_1090_output_data.csv  data/model_2090_output_data.csv
data/model_1091_output_data.csv  data/model_2091_output_data.csv
data/model_1092_output_data.csv  data/model_2092_output_data.csv
data/model_1093_output_data.csv  data/model_2093_output_data.csv
data/model_1094_output_data.csv  data/model_2094_output_data.csv
data/model_1095_output_data.csv  data/model_2095_output_data.csv
data/model_1096_output_data.csv  data/model_2096_output_data.csv
data/model_1097_output_data.csv  data/model_2097_output_data.csv
data/model_1098_output_data.csv  data/model_2098_output_data.csv
data/model_1099_output_data.csv  data/model_2099_output_data.csv
data/model_1100_output_data.csv  data/model_2100_output_data.csv
data/model_1101_output_data.csv  data/model_2101_output_data.csv
data/model_1102_output_data.csv  data/model_2102_output_data.csv
data/model_1103_output_data.csv  data/model_2103_output_data.csv
data/model_1104_output_data.csv  data/model_2104_output_data.csv
data/model_1105_output_data.csv  data/model_2105_output_data.csv
data/model_1106_output_data.csv  data/model_2106_output_data.csv
data/model_1107_output_data.csv  data/model_2107_output_data.csv
data/model_1108_output_data.csv  data/model_2108_output_data.csv
data/model_1109_output_data.csv  data/model_2109_output_data.csv
data/model_1110_output_data.csv  data/model_2110_output_data.csv
data/model_1111_output_data.csv  data/model_2111_output_data.csv
data/model_1112_output_data.csv  data/model_2112_output_data.csv
data/model_1113_output_data.csv  data/model_2113_output_data.csv
data/model_1114_output_data.csv  data/model_2114_output_data.csv
data/model_1115_output_data.csv  data/model_2115_output_data.csv
data/model_1116_output_data.csv  data/model_2116_output_data.csv
data/model_1117_output_data.csv  data/model_2117_output_data.csv
data/model_1118_output_data.csv  data/model_2118_output_data.csv
data/model_1119_output_data.csv  data/model_2119_output_data.csv
data/model_1120_output_data.csv  data/model_2120_output_data.csv
data/model_1121_output_data.csv  data/model_2121_output_data.csv
data/model_1122_output_data.csv  data/model_2122_output_data.csv
data/model_1123_output_data.csv  data/model_2123_output_data.csv
data/model_1124_output_data.csv  data/model_2124_output_data.csv
data/model_1125_output_data.csv  data/model_2125_output_data.csv
data/model_1126_output_data.csv  data/model_2126_output_data.csv
data/model_1127_output_data.csv  data/model_2127_output_data.csv
data/model_1128_output_data.csv  data/model_2128_output_data.csv
data/model_1129_output_data.csv  data/model_2129_output_data.csv
data/model_1130_output_data.csv  data/model_2130_output_data.csv
data/model_1131_output_data.csv  data/model_2131_output_data.csv
data/model_1132_output_data.csv  data/model_2132_output_data.csv
data/model_1133_output_data.csv  data/model_2133_output_data.csv
data/model_1134_output_data.csv  data/model_2134_output_data.csv
data/model_1135_output_data.csv  data/model_2135_output_data.csv
data/model_1136_output_data.csv  data/model_2136_output_data.csv
data/model_1137_output_data.csv  data/model_2137_output_data.csv
data/model_1138_output_data.csv  data/model_2138_output_data.csv
data/model_1139_output_data.csv  data/model_2139_output_data.csv
data/model_1140_output_data.csv  data/model_2140_output_data.csv
data/model_1141_output_data.csv  data/model_2141_output_data.csv
data/model_1142_output_data.csv  data/model_2142_output_data.csv
data/model_1143_output_data.csv  data/model_2143_output_data.csv
data/model_1144_output_data.csv  data/model_2144_output_data.csv
data/model_1145_output_data.csv  data/model_2145_output_data.csv
data/model_1146_output_data.csv  data/model_2146_output_data.csv
data/model_1147_output_data.csv  data/model_2147_output_data.csv
data/model_1148_output_data.csv  data/model_2148_output_data.csv
data/model_1149_output_data.csv  data/model_2149_output_data.csv
data/model_1150_output_data.csv  data/model_2150_output_data.csv
data/model_1151_output_data.csv  data/model_2151_output_data.csv
data/model_1152_output_data.csv  data/model_2152_output_data.csv
data/model_1153_output_data.csv  data/model_2153_output_data.csv
data/model_1154_output_data.csv  data/model_2154_output_data.csv
data/model_1155_output_data.csv  data/model_2155_output_data.csv
data/model_1156_output_data.csv  data/model_2156_output_data.csv
data/model_1157_output_data.csv  data/model_2157_output_data.csv
data/model_1158_output_data.csv  data/model_2158_output_data.csv
data/model_1159_output_data.csv  data/model_2159_output_data.csv
data/model_1160_output_data.csv  data/model_2160_output_data.csv
data/model_1161_output_data.csv  data/model_2161_output_data.csv
data/model_1162_output_data.csv  data/model_2162_output_data.csv
data/model_1163_output_data.csv  data/model_2163_output_data.csv
data/model_1164_output_data.csv  data/model_2164_output_data.csv
data/model_1165_output_data.csv  data/model_2165_output_data.csv
data/model_1166_output_data.csv  data/model_2166_output_data.csv
data/model_1167_output_data.csv  data/model_2167_output_data.csv
data/model_1168_output_data.csv  data/model_2168_output_data.csv
data/model_1169_output_data.csv  data/model_2169_output_data.csv
data/model_1170_output_data.csv  data/model_2170_output_data.csv
data/model_1171_output_data.csv  data/model_2171_output_data.csv
data/model_1172_output_data.csv  data/model_2172_output_data.csv
data/model_1173_output_data.csv  data/model_2173_output_data.csv
data/model_1174_output_data.csv  data/model_2174_output_data.csv
data/model_1175_output_data.csv  data/model_2175_output_data.csv
data/model_1176_output_data.csv  data/model_2176_output_data.csv
data/model_1177_output_data.csv  data/model_2177_output_data.csv
data/model_1178_output_data.csv  data/model_2178_output_data.csv
data/model_1179_output_data.csv  data/model_2179_output_data.csv
data/model_1180_output_data.csv  data/model_2180_output_data.csv
data/model_1181_output_data.csv  data/model_2181_output_data.csv
data/model_1182_output_data.csv  data/model_2182_output_data.csv
data/model_1183_output_data.csv  data/model_2183_output_data.csv
data/model_1184_output_data.csv  data/model_2184_output_data.csv
data/model_1185_output_data.csv  data/model_2185_output_data.csv
data/model_1186_output_data.csv  data/model_2186_output_data.csv
data/model_1187_output_data.csv  data/model_2187_output_data.csv
data/model_1188_output_data.csv  data/model_2188_output_data.csv
data/model_1189_output_data.csv  data/model_2189_output_data.csv
data/model_1190_output_data.csv  data/model_2190_output_data.csv
data/model_1191_output_data.csv  data/model_2191_output_data.csv
data/model_1192_output_data.csv  data/model_2192_output_data.csv
data/model_1193_output_data.csv  data/model_2193_output_data.csv
data/model_1194_output_data.csv  data/model_2194_output_data.csv
data/model_1195_output_data.csv  data/model_2195_output_data.csv
data/model_1196_output_data.csv  data/model_2196_output_data.csv
data/model_1197_output_data.csv  data/model_2197_output_data.csv
data/model_1198_output_data.csv  data/model_2198_output_data.csv
data/model_1199_output_data.csv  data/model_2199_output_data.csv
data/model_1200_output_data.csv  data/model_2200_output_data.csv
data/model_1201_output_data.csv  data/model_2201_output_data.csv
data/model_1202_output_data.csv  data/model_2202_output_data.csv
data/model_1203_output_data.csv  data/model_2203_output_data.csv
data/model_1204_output_data.csv  data/model_2204_output_data.csv
data/model_1205_output_data.csv  data/model_2205_output_data.csv
data/model_1206_output_data.csv  data/model_2206_output_data.csv
data/model_1207_output_data.csv  data/model_2207_output_data.csv
data/model_1208_output_data.csv  data/model_2208_output_data.csv
data/model_1209_output_data.csv  data/model_2209_output_data.csv
data/model_1210_output_data.csv  data/model_2210_output_data.csv
data/model_1211_output_data.csv  data/model_2211_output_data.csv
data/model_1212_output_data.csv  data/model_2212_output_data.csv
data/model_1213_output_data.csv  data/model_2213_output_data.csv
data/model_1214_output_data.csv  data/model_2214_output_data.csv
data/model_1215_output_data.csv  data/model_2215_output_data.csv
data/model_1216_output_data.csv  data/model_2216_output_data.csv
data/model_1217_output_data.csv  data/model_2217_output_data.csv
data/model_1218_output_data.csv  data/model_2218_output_data.csv
data/model_1219_output_data.csv  data/model_2219_output_data.csv
data/model_1220_output_data.csv  data/model_2220_output_data.csv
data/model_1221_output_data.csv  data/model_2221_output_data.csv
data/model_1222_output_data.csv  data/model_2222_output_data.csv
data/model_1223_output_data.csv  data/model_2223_output_data.csv
data/model_1224_output_data.csv  data/model_2224_output_data.csv
data/model_1225_output_data.csv  data/model_2225_output_data.csv
data/model_1226_output_data.csv  data/model_2226_output_data.csv
data/model_1227_output_data.csv  data/model_2227_output_data.csv
data/model_1228_output_data.csv  data/model_2228_output_data.csv
data/model_1229_output_data.csv  data/model_2229_output_data.csv
data/model_1230_output_data.csv  data/model_2230_output_data.csv
data/model_1231_output_data.csv  data/model_2231_output_data.csv
data/model_1232_output_data.csv  data/model_2232_output_data.csv
data/model_1233_output_data.csv  data/model_2233_output_data.csv
data/model_1234_output_data.csv  data/model_2234_output_data.csv
data/model_1235_output_data.csv  data/model_2235_output_data.csv
data/model_1236_output_data.csv  data/model_2236_output_data.csv
data/model_1237_output_data.csv  data/model_2237_output_data.csv
data/model_1238_output_data.csv  data/model_2238_output_data.csv
data/model_1239_output_data.csv  data/model_2239_output_data.csv
data/model_1240_output_data.csv  data/model_2240_output_data.csv
data/model_1241_output_data.csv  data/model_2241_output_data.csv
data/model_1242_output_data.csv  data/model_2242_output_data.csv
data/model_1243_output_data.csv  data/model_2243_output_data.csv
data/model_1244_output_data.csv  data/model_2244_output_data.csv
data/model_1245_output_data.csv  data/model_2245_output_data.csv
data/model_1246_output_data.csv  data/model_2246_output_data.csv
data/model_1247_output_data.csv  data/model_2247_output_data.csv
data/model_1248_output_data.csv  data/model_2248_output_data.csv
data/model_1249_output_data.csv  data/model_2249_output_data.csv
data/model_1250_output_data.csv  data/model_2250_output_data.csv
data/model_1251_output_data.csv  data/model_2251_output_data.csv
data/model_1252_output_data.csv  data/model_2252_output_data.csv
data/model_1253_output_data.csv  data/model_2253_output_data.csv
data/model_1254_output_data.csv  data/model_2254_output_data.csv
data/model_1255_output_data.csv  data/model_2255_output_data.csv
data/model_1256_output_data.csv  data/model_2256_output_data.csv
data/model_1257_output_data.csv  data/model_2257_output_data.csv
data/model_1258_output_data.csv  data/model_2258_output_data.csv
data/model_1259_output_data.csv  data/model_2259_output_data.csv
data/model_1260_output_data.csv  data/model_2260_output_data.csv
data/model_1261_output_data.csv  data/model_2261_output_data.csv
data/model_1262_output_data.csv  data/model_2262_output_data.csv
data/model_1263_output_data.csv  data/model_2263_output_data.csv
data/model_1264_output_data.csv  data/model_2264_output_data.csv
data/model_1265_output_data.csv  data/model_2265_output_data.csv
data/model_1266_output_data.csv  data/model_2266_output_data.csv
data/model_1267_output_data.csv  data/model_2267_output_data.csv
data/model_1268_output_data.csv  data/model_2268_output_data.csv
data/model_1269_output_data.csv  data/model_2269_output_data.csv
data/model_1270_output_data.csv  data/model_2270_output_data.csv
data/model_1271_output_data.csv  data/model_2271_output_data.csv
data/model_1272_output_data.csv  data/model_2272_output_data.csv
data/model_1273_output_data.csv  data/model_2273_output_data.csv
data/model_1274_output_data.csv  data/model_2274_output_data.csv
data/model_1275_output_data.csv  data/model_2275_output_data.csv
data/model_1276_output_data.csv  data/model_2276_output_data.csv
data/model_1277_output_data.csv  data/model_2277_output_data.csv
data/model_1278_output_data.csv  data/model_2278_output_data.csv
data/model_1279_output_data.csv  data/model_2279_output_data.csv
data/model_1280_output_data.csv  data/model_2280_output_data.csv
data/model_1281_output_data.csv  data/model_2281_output_data.csv
data/model_1282_output_data.csv  data/model_2282_output_data.csv
data/model_1283_output_data.csv  data/model_2283_output_data.csv
data/model_1284_output_data.csv  data/model_2284_output_data.csv
data/model_1285_output_data.csv  data/model_2285_output_data.csv
data/model_1286_output_data.csv  data/model_2286_output_data.csv
data/model_1287_output_data.csv  data/model_2287_output_data.csv
data/model_1288_output_data.csv  data/model_2288_output_data.csv
data/model_1289_output_data.csv  data/model_2289_output_data.csv
data/model_1290_output_data.csv  data/model_2290_output_data.csv
data/model_1291_output_data.csv  data/model_2291_output_data.csv
data/model_1292_output_data.csv  data/model_2292_output_data.csv
data/model_1293_output_data.csv  data/model_2293_output_data.csv
data/model_1294_output_data.csv  data/model_2294_output_data.csv
data/model_1295_output_data.csv  data/model_2295_output_data.csv
data/model_1296_output_data.csv  data/model_2296_output_data.csv
data/model_1297_output_data.csv  data/model_2297_output_data.csv
data/model_1298_output_data.csv  data/model_2298_output_data.csv
data/model_1299_output_data.csv  data/model_2299_output_data.csv
data/model_1300_output_data.csv  data/model_2300_output_data.csv
data/model_1301_output_data.csv  data/model_2301_output_data.csv
data/model_1302_output_data.csv  data/model_2302_output_data.csv
data/model_1303_output_data.csv  data/model_2303_output_data.csv
data/model_1304_output_data.csv  data/model_2304_output_data.csv
data/model_1305_output_data.csv  data/model_2305_output_data.csv
data/model_1306_output_data.csv  data/model_2306_output_data.csv
data/model_1307_output_data.csv  data/model_2307_output_data.csv
data/model_1308_output_data.csv  data/model_2308_output_data.csv
data/model_1309_output_data.csv  data/model_2309_output_data.csv
data/model_1310_output_data.csv  data/model_2310_output_data.csv
data/model_1311_output_data.csv  data/model_2311_output_data.csv
data/model_1312_output_data.csv  data/model_2312_output_data.csv
data/model_1313_output_data.csv  data/model_2313_output_data.csv
data/model_1314_output_data.csv  data/model_2314_output_data.csv
data/model_1315_output_data.csv  data/model_2315_output_data.csv
data/model_1316_output_data.csv  data/model_2316_output_data.csv
data/model_1317_output_data.csv  data/model_2317_output_data.csv
data/model_1318_output_data.csv  data/model_2318_output_data.csv
data/model_1319_output_data.csv  data/model_2319_output_data.csv
data/model_1320_output_data.csv  data/model_2320_output_data.csv
data/model_1321_output_data.csv  data/model_2321_output_data.csv
data/model_1322_output_data.csv  data/model_2322_output_data.csv
data/model_1323_output_data.csv  data/model_2323_output_data.csv
data/model_1324_output_data.csv  data/model_2324_output_data.csv
data/model_1325_output_data.csv  data/model_2325_output_data.csv
data/model_1326_output_data.csv  data/model_2326_output_data.csv
data/model_1327_output_data.csv  data/model_2327_output_data.csv
data/model_1328_output_data.csv  data/model_2328_output_data.csv
data/model_1329_output_data.csv  data/model_2329_output_data.csv
data/model_1330_output_data.csv  data/model_2330_output_data.csv
data/model_1331_output_data.csv  data/model_2331_output_data.csv
data/model_1332_output_data.csv  data/model_2332_output_data.csv
data/model_1333_output_data.csv  data/model_2333_output_data.csv
data/model_1334_output_data.csv  data/model_2334_output_data.csv
data/model_1335_output_data.csv  data/model_2335_output_data.csv
data/model_1336_output_data.csv  data/model_2336_output_data.csv
data/model_1337_output_data.csv  data/model_2337_output_data.csv
data/model_1338_output_data.csv  data/model_2338_output_data.csv
data/model_1339_output_data.csv  data/model_2339_output_data.csv
data/model_1340_output_data.csv  data/model_2340_output_data.csv
data/model_1341_output_data.csv  data/model_2341_output_data.csv
data/model_1342_output_data.csv  data/model_2342_output_data.csv
data/model_1343_output_data.csv  data/model_2343_output_data.csv
data/model_1344_output_data.csv  data/model_2344_output_data.csv
data/model_1345_output_data.csv  data/model_2345_output_data.csv
data/model_1346_output_data.csv  data/model_2346_output_data.csv
data/model_1347_output_data.csv  data/model_2347_output_data.csv
data/model_1348_output_data.csv  data/model_2348_output_data.csv
data/model_1349_output_data.csv  data/model_2349_output_data.csv
data/model_1350_output_data.csv  data/model_2350_output_data.csv
data/model_1351_output_data.csv  data/model_2351_output_data.csv
data/model_1352_output_data.csv  data/model_2352_output_data.csv
data/model_1353_output_data.csv  data/model_2353_output_data.csv
data/model_1354_output_data.csv  data/model_2354_output_data.csv
data/model_1355_output_data.csv  data/model_2355_output_data.csv
data/model_1356_output_data.csv  data/model_2356_output_data.csv
data/model_1357_output_data.csv  data/model_2357_output_data.csv
data/model_1358_output_data.csv  data/model_2358_output_data.csv
data/model_1359_output_data.csv  data/model_2359_output_data.csv
data/model_1360_output_data.csv  data/model_2360_output_data.csv
data/model_1361_output_data.csv  data/model_2361_output_data.csv
data/model_1362_output_data.csv  data/model_2362_output_data.csv
data/model_1363_output_data.csv  data/model_2363_output_data.csv
data/model_1364_output_data.csv  data/model_2364_output_data.csv
data/model_1365_output_data.csv  data/model_2365_output_data.csv
data/model_1366_output_data.csv  data/model_2366_output_data.csv
data/model_1367_output_data.csv  data/model_2367_output_data.csv
data/model_1368_output_data.csv  data/model_2368_output_data.csv
data/model_1369_output_data.csv  data/model_2369_output_data.csv
data/model_1370_output_data.csv  data/model_2370_output_data.csv
data/model_1371_output_data.csv  data/model_2371_output_data.csv
data/model_1372_output_data.csv  data/model_2372_output_data.csv
data/model_1373_output_data.csv  data/model_2373_output_data.csv
data/model_1374_output_data.csv  data/model_2374_output_data.csv
data/model_1375_output_data.csv  data/model_2375_output_data.csv
data/model_1376_output_data.csv  data/model_2376_output_data.csv
data/model_1377_output_data.csv  data/model_2377_output_data.csv
data/model_1378_output_data.csv  data/model_2378_output_data.csv
data/model_1379_output_data.csv  data/model_2379_output_data.csv
data/model_1380_output_data.csv  data/model_2380_output_data.csv
data/model_1381_output_data.csv  data/model_2381_output_data.csv
data/model_1382_output_data.csv  data/model_2382_output_data.csv
data/model_1383_output_data.csv  data/model_2383_output_data.csv
data/model_1384_output_data.csv  data/model_2384_output_data.csv
data/model_1385_output_data.csv  data/model_2385_output_data.csv
data/model_1386_output_data.csv  data/model_2386_output_data.csv
data/model_1387_output_data.csv  data/model_2387_output_data.csv
data/model_1388_output_data.csv  data/model_2388_output_data.csv
data/model_1389_output_data.csv  data/model_2389_output_data.csv
data/model_1390_output_data.csv  data/model_2390_output_data.csv
data/model_1391_output_data.csv  data/model_2391_output_data.csv
data/model_1392_output_data.csv  data/model_2392_output_data.csv
data/model_1393_output_data.csv  data/model_2393_output_data.csv
data/model_1394_output_data.csv  data/model_2394_output_data.csv
data/model_1395_output_data.csv  data/model_2395_output_data.csv
data/model_1396_output_data.csv  data/model_2396_output_data.csv
data/model_1397_output_data.csv  data/model_2397_output_data.csv
data/model_1398_output_data.csv  data/model_2398_output_data.csv
data/model_1399_output_data.csv  data/model_2399_output_data.csv
data/model_1400_output_data.csv  data/model_2400_output_data.csv
data/model_1401_output_data.csv  data/model_2401_output_data.csv
data/model_1402_output_data.csv  data/model_2402_output_data.csv
data/model_1403_output_data.csv  data/model_2403_output_data.csv
data/model_1404_output_data.csv  data/model_2404_output_data.csv
data/model_1405_output_data.csv  data/model_2405_output_data.csv
data/model_1406_output_data.csv  data/model_2406_output_data.csv
data/model_1407_output_data.csv  data/model_2407_output_data.csv
data/model_1408_output_data.csv  data/model_2408_output_data.csv
data/model_1409_output_data.csv  data/model_2409_output_data.csv
data/model_1410_output_data.csv  data/model_2410_output_data.csv
data/model_1411_output_data.csv  data/model_2411_output_data.csv
data/model_1412_output_data.csv  data/model_2412_output_data.csv
data/model_1413_output_data.csv  data/model_2413_output_data.csv
data/model_1414_output_data.csv  data/model_2414_output_data.csv
data/model_1415_output_data.csv  data/model_2415_output_data.csv
data/model_1416_output_data.csv  data/model_2416_output_data.csv
data/model_1417_output_data.csv  data/model_2417_output_data.csv
data/model_1418_output_data.csv  data/model_2418_output_data.csv
data/model_1419_output_data.csv  data/model_2419_output_data.csv
data/model_1420_output_data.csv  data/model_2420_output_data.csv
data/model_1421_output_data.csv  data/model_2421_output_data.csv
data/model_1422_output_data.csv  data/model_2422_output_data.csv
data/model_1423_output_data.csv  data/model_2423_output_data.csv
data/model_1424_output_data.csv  data/model_2424_output_data.csv
data/model_1425_output_data.csv  data/model_2425_output_data.csv
data/model_1426_output_data.csv  data/model_2426_output_data.csv
data/model_1427_output_data.csv  data/model_2427_output_data.csv
data/model_1428_output_data.csv  data/model_2428_output_data.csv
data/model_1429_output_data.csv  data/model_2429_output_data.csv
data/model_1430_output_data.csv  data/model_2430_output_data.csv
data/model_1431_output_data.csv  data/model_2431_output_data.csv
data/model_1432_output_data.csv  data/model_2432_output_data.csv
data/model_1433_output_data.csv  data/model_2433_output_data.csv
data/model_1434_output_data.csv  data/model_2434_output_data.csv
data/model_1435_output_data.csv  data/model_2435_output_data.csv
data/model_1436_output_data.csv  data/model_2436_output_data.csv
data/model_1437_output_data.csv  data/model_2437_output_data.csv
data/model_1438_output_data.csv  data/model_2438_output_data.csv
data/model_1439_output_data.csv  data/model_2439_output_data.csv
data/model_1440_output_data.csv  data/model_2440_output_data.csv
data/model_1441_output_data.csv  data/model_2441_output_data.csv
data/model_1442_output_data.csv  data/model_2442_output_data.csv
data/model_1443_output_data.csv  data/model_2443_output_data.csv
data/model_1444_output_data.csv  data/model_2444_output_data.csv
data/model_1445_output_data.csv  data/model_2445_output_data.csv
data/model_1446_output_data.csv  data/model_2446_output_data.csv
data/model_1447_output_data.csv  data/model_2447_output_data.csv
data/model_1448_output_data.csv  data/model_2448_output_data.csv
data/model_1449_output_data.csv  data/model_2449_output_data.csv
data/model_1450_output_data.csv  data/model_2450_output_data.csv
data/model_1451_output_data.csv  data/model_2451_output_data.csv
data/model_1452_output_data.csv  data/model_2452_output_data.csv
data/model_1453_output_data.csv  data/model_2453_output_data.csv
data/model_1454_output_data.csv  data/model_2454_output_data.csv
data/model_1455_output_data.csv  data/model_2455_output_data.csv
data/model_1456_output_data.csv  data/model_2456_output_data.csv
data/model_1457_output_data.csv  data/model_2457_output_data.csv
data/model_1458_output_data.csv  data/model_2458_output_data.csv
data/model_1459_output_data.csv  data/model_2459_output_data.csv
data/model_1460_output_data.csv  data/model_2460_output_data.csv
data/model_1461_output_data.csv  data/model_2461_output_data.csv
data/model_1462_output_data.csv  data/model_2462_output_data.csv
data/model_1463_output_data.csv  data/model_2463_output_data.csv
data/model_1464_output_data.csv  data/model_2464_output_data.csv
data/model_1465_output_data.csv  data/model_2465_output_data.csv
data/model_1466_output_data.csv  data/model_2466_output_data.csv
data/model_1467_output_data.csv  data/model_2467_output_data.csv
data/model_1468_output_data.csv  data/model_2468_output_data.csv
data/model_1469_output_data.csv  data/model_2469_output_data.csv
data/model_1470_output_data.csv  data/model_2470_output_data.csv
data/model_1471_output_data.csv  data/model_2471_output_data.csv
data/model_1472_output_data.csv  data/model_2472_output_data.csv
data/model_1473_output_data.csv  data/model_2473_output_data.csv
data/model_1474_output_data.csv  data/model_2474_output_data.csv
data/model_1475_output_data.csv  data/model_2475_output_data.csv
data/model_1476_output_data.csv  data/model_2476_output_data.csv
data/model_1477_output_data.csv  data/model_2477_output_data.csv
data/model_1478_output_data.csv  data/model_2478_output_data.csv
data/model_1479_output_data.csv  data/model_2479_output_data.csv
data/model_1480_output_data.csv  data/model_2480_output_data.csv
data/model_1481_output_data.csv  data/model_2481_output_data.csv
data/model_1482_output_data.csv  data/model_2482_output_data.csv
data/model_1483_output_data.csv  data/model_2483_output_data.csv
data/model_1484_output_data.csv  data/model_2484_output_data.csv
data/model_1485_output_data.csv  data/model_2485_output_data.csv
data/model_1486_output_data.csv  data/model_2486_output_data.csv
data/model_1487_output_data.csv  data/model_2487_output_data.csv
data/model_1488_output_data.csv  data/model_2488_output_data.csv
data/model_1489_output_data.csv  data/model_2489_output_data.csv
data/model_1490_output_data.csv  data/model_2490_output_data.csv
data/model_1491_output_data.csv  data/model_2491_output_data.csv
data/model_1492_output_data.csv  data/model_2492_output_data.csv
data/model_1493_output_data.csv  data/model_2493_output_data.csv
data/model_1494_output_data.csv  data/model_2494_output_data.csv
data/model_1495_output_data.csv  data/model_2495_output_data.csv
data/model_1496_output_data.csv  data/model_2496_output_data.csv
data/model_1497_output_data.csv  data/model_2497_output_data.csv
data/model_1498_output_data.csv  data/model_2498_output_data.csv
data/model_1499_output_data.csv  data/model_2499_output_data.csv
data/model_1500_output_data.csv  data/model_2500_output_data.csv
data/model_1501_output_data.csv  data/model_2501_output_data.csv
data/model_1502_output_data.csv  data/model_2502_output_data.csv
data/model_1503_output_data.csv  data/model_2503_output_data.csv
data/model_1504_output_data.csv  data/model_2504_output_data.csv
data/model_1505_output_data.csv  data/model_2505_output_data.csv
data/model_1506_output_data.csv  data/model_2506_output_data.csv
data/model_1507_output_data.csv  data/model_2507_output_data.csv
data/model_1508_output_data.csv  data/model_2508_output_data.csv
data/model_1509_output_data.csv  data/model_2509_output_data.csv
data/model_1510_output_data.csv  data/model_2510_output_data.csv
data/model_1511_output_data.csv  data/model_2511_output_data.csv
data/model_1512_output_data.csv  data/model_2512_output_data.csv
data/model_1513_output_data.csv  data/model_2513_output_data.csv
data/model_1514_output_data.csv  data/model_2514_output_data.csv
data/model_1515_output_data.csv  data/model_2515_output_data.csv
data/model_1516_output_data.csv  data/model_2516_output_data.csv
data/model_1517_output_data.csv  data/model_2517_output_data.csv
data/model_1518_output_data.csv  data/model_2518_output_data.csv
data/model_1519_output_data.csv  data/model_2519_output_data.csv
data/model_1520_output_data.csv  data/model_2520_output_data.csv
data/model_1521_output_data.csv  data/model_2521_output_data.csv
data/model_1522_output_data.csv  data/model_2522_output_data.csv
data/model_1523_output_data.csv  data/model_2523_output_data.csv
data/model_1524_output_data.csv  data/model_2524_output_data.csv
data/model_1525_output_data.csv  data/model_2525_output_data.csv
data/model_1526_output_data.csv  data/model_2526_output_data.csv
data/model_1527_output_data.csv  data/model_2527_output_data.csv
data/model_1528_output_data.csv  data/model_2528_output_data.csv
data/model_1529_output_data.csv  data/model_2529_output_data.csv
data/model_1530_output_data.csv  data/model_2530_output_data.csv
data/model_1531_output_data.csv  data/model_2531_output_data.csv
data/model_1532_output_data.csv  data/model_2532_output_data.csv
data/model_1533_output_data.csv  data/model_2533_output_data.csv
data/model_1534_output_data.csv  data/model_2534_output_data.csv
data/model_1535_output_data.csv  data/model_2535_output_data.csv
data/model_1536_output_data.csv  data/model_2536_output_data.csv
data/model_1537_output_data.csv  data/model_2537_output_data.csv
data/model_1538_output_data.csv  data/model_2538_output_data.csv
data/model_1539_output_data.csv  data/model_2539_output_data.csv
data/model_1540_output_data.csv  data/model_2540_output_data.csv
data/model_1541_output_data.csv  data/model_2541_output_data.csv
data/model_1542_output_data.csv  data/model_2542_output_data.csv
data/model_1543_output_data.csv  data/model_2543_output_data.csv
data/model_1544_output_data.csv  data/model_2544_output_data.csv
data/model_1545_output_data.csv  data/model_2545_output_data.csv
data/model_1546_output_data.csv  data/model_2546_output_data.csv
data/model_1547_output_data.csv  data/model_2547_output_data.csv
data/model_1548_output_data.csv  data/model_2548_output_data.csv
data/model_1549_output_data.csv  data/model_2549_output_data.csv
data/model_1550_output_data.csv  data/model_2550_output_data.csv
data/model_1551_output_data.csv  data/model_2551_output_data.csv
data/model_1552_output_data.csv  data/model_2552_output_data.csv
data/model_1553_output_data.csv  data/model_2553_output_data.csv
data/model_1554_output_data.csv  data/model_2554_output_data.csv
data/model_1555_output_data.csv  data/model_2555_output_data.csv
data/model_1556_output_data.csv  data/model_2556_output_data.csv
data/model_1557_output_data.csv  data/model_2557_output_data.csv
data/model_1558_output_data.csv  data/model_2558_output_data.csv
data/model_1559_output_data.csv  data/model_2559_output_data.csv
data/model_1560_output_data.csv  data/model_2560_output_data.csv
data/model_1561_output_data.csv  data/model_2561_output_data.csv
data/model_1562_output_data.csv  data/model_2562_output_data.csv
data/model_1563_output_data.csv  data/model_2563_output_data.csv
data/model_1564_output_data.csv  data/model_2564_output_data.csv
data/model_1565_output_data.csv  data/model_2565_output_data.csv
data/model_1566_output_data.csv  data/model_2566_output_data.csv
data/model_1567_output_data.csv  data/model_2567_output_data.csv
data/model_1568_output_data.csv  data/model_2568_output_data.csv
data/model_1569_output_data.csv  data/model_2569_output_data.csv
data/model_1570_output_data.csv  data/model_2570_output_data.csv
data/model_1571_output_data.csv  data/model_2571_output_data.csv
data/model_1572_output_data.csv  data/model_2572_output_data.csv
data/model_1573_output_data.csv  data/model_2573_output_data.csv
data/model_1574_output_data.csv  data/model_2574_output_data.csv
data/model_1575_output_data.csv  data/model_2575_output_data.csv
data/model_1576_output_data.csv  data/model_2576_output_data.csv
data/model_1577_output_data.csv  data/model_2577_output_data.csv
data/model_1578_output_data.csv  data/model_2578_output_data.csv
data/model_1579_output_data.csv  data/model_2579_output_data.csv
data/model_1580_output_data.csv  data/model_2580_output_data.csv
data/model_1581_output_data.csv  data/model_2581_output_data.csv
data/model_1582_output_data.csv  data/model_2582_output_data.csv
data/model_1583_output_data.csv  data/model_2583_output_data.csv
data/model_1584_output_data.csv  data/model_2584_output_data.csv
data/model_1585_output_data.csv  data/model_2585_output_data.csv
data/model_1586_output_data.csv  data/model_2586_output_data.csv
data/model_1587_output_data.csv  data/model_2587_output_data.csv
data/model_1588_output_data.csv  data/model_2588_output_data.csv
data/model_1589_output_data.csv  data/model_2589_output_data.csv
data/model_1590_output_data.csv  data/model_2590_output_data.csv
data/model_1591_output_data.csv  data/model_2591_output_data.csv
data/model_1592_output_data.csv  data/model_2592_output_data.csv
data/model_1593_output_data.csv  data/model_2593_output_data.csv
data/model_1594_output_data.csv  data/model_2594_output_data.csv
data/model_1595_output_data.csv  data/model_2595_output_data.csv
data/model_1596_output_data.csv  data/model_2596_output_data.csv
data/model_1597_output_data.csv  data/model_2597_output_data.csv
data/model_1598_output_data.csv  data/model_2598_output_data.csv
data/model_1599_output_data.csv  data/model_2599_output_data.csv
data/model_1600_output_data.csv  data/model_2600_output_data.csv
data/model_1601_output_data.csv  data/model_2601_output_data.csv
data/model_1602_output_data.csv  data/model_2602_output_data.csv
data/model_1603_output_data.csv  data/model_2603_output_data.csv
data/model_1604_output_data.csv  data/model_2604_output_data.csv
data/model_1605_output_data.csv  data/model_2605_output_data.csv
data/model_1606_output_data.csv  data/model_2606_output_data.csv
data/model_1607_output_data.csv  data/model_2607_output_data.csv
data/model_1608_output_data.csv  data/model_2608_output_data.csv
data/model_1609_output_data.csv  data/model_2609_output_data.csv
data/model_1610_output_data.csv  data/model_2610_output_data.csv
data/model_1611_output_data.csv  data/model_2611_output_data.csv
data/model_1612_output_data.csv  data/model_2612_output_data.csv
data/model_1613_output_data.csv  data/model_2613_output_data.csv
data/model_1614_output_data.csv  data/model_2614_output_data.csv
data/model_1615_output_data.csv  data/model_2615_output_data.csv
data/model_1616_output_data.csv  data/model_2616_output_data.csv
data/model_1617_output_data.csv  data/model_2617_output_data.csv
data/model_1618_output_data.csv  data/model_2618_output_data.csv
data/model_1619_output_data.csv  data/model_2619_output_data.csv
data/model_1620_output_data.csv  data/model_2620_output_data.csv
data/model_1621_output_data.csv  data/model_2621_output_data.csv
data/model_1622_output_data.csv  data/model_2622_output_data.csv
data/model_1623_output_data.csv  data/model_2623_output_data.csv
data/model_1624_output_data.csv  data/model_2624_output_data.csv
data/model_1625_output_data.csv  data/model_2625_output_data.csv
data/model_1626_output_data.csv  data/model_2626_output_data.csv
data/model_1627_output_data.csv  data/model_2627_output_data.csv
data/model_1628_output_data.csv  data/model_2628_output_data.csv
data/model_1629_output_data.csv  data/model_2629_output_data.csv
data/model_1630_output_data.csv  data/model_2630_output_data.csv
data/model_1631_output_data.csv  data/model_2631_output_data.csv
data/model_1632_output_data.csv  data/model_2632_output_data.csv
data/model_1633_output_data.csv  data/model_2633_output_data.csv
data/model_1634_output_data.csv  data/model_2634_output_data.csv
data/model_1635_output_data.csv  data/model_2635_output_data.csv
data/model_1636_output_data.csv  data/model_2636_output_data.csv
data/model_1637_output_data.csv  data/model_2637_output_data.csv
data/model_1638_output_data.csv  data/model_2638_output_data.csv
data/model_1639_output_data.csv  data/model_2639_output_data.csv
data/model_1640_output_data.csv  data/model_2640_output_data.csv
data/model_1641_output_data.csv  data/model_2641_output_data.csv
data/model_1642_output_data.csv  data/model_2642_output_data.csv
data/model_1643_output_data.csv  data/model_2643_output_data.csv
data/model_1644_output_data.csv  data/model_2644_output_data.csv
data/model_1645_output_data.csv  data/model_2645_output_data.csv
data/model_1646_output_data.csv  data/model_2646_output_data.csv
data/model_1647_output_data.csv  data/model_2647_output_data.csv
data/model_1648_output_data.csv  data/model_2648_output_data.csv
data/model_1649_output_data.csv  data/model_2649_output_data.csv
data/model_1650_output_data.csv  data/model_2650_output_data.csv
data/model_1651_output_data.csv  data/model_2651_output_data.csv
data/model_1652_output_data.csv  data/model_2652_output_data.csv
data/model_1653_output_data.csv  data/model_2653_output_data.csv
data/model_1654_output_data.csv  data/model_2654_output_data.csv
data/model_1655_output_data.csv  data/model_2655_output_data.csv
data/model_1656_output_data.csv  data/model_2656_output_data.csv
data/model_1657_output_data.csv  data/model_2657_output_data.csv
data/model_1658_output_data.csv  data/model_2658_output_data.csv
data/model_1659_output_data.csv  data/model_2659_output_data.csv
data/model_1660_output_data.csv  data/model_2660_output_data.csv
data/model_1661_output_data.csv  data/model_2661_output_data.csv
data/model_1662_output_data.csv  data/model_2662_output_data.csv
data/model_1663_output_data.csv  data/model_2663_output_data.csv
data/model_1664_output_data.csv  data/model_2664_output_data.csv
data/model_1665_output_data.csv  data/model_2665_output_data.csv
data/model_1666_output_data.csv  data/model_2666_output_data.csv
data/model_1667_output_data.csv  data/model_2667_output_data.csv
data/model_1668_output_data.csv  data/model_2668_output_data.csv
data/model_1669_output_data.csv  data/model_2669_output_data.csv
data/model_1670_output_data.csv  data/model_2670_output_data.csv
data/model_1671_output_data.csv  data/model_2671_output_data.csv
data/model_1672_output_data.csv  data/model_2672_output_data.csv
data/model_1673_output_data.csv  data/model_2673_output_data.csv
data/model_1674_output_data.csv  data/model_2674_output_data.csv
data/model_1675_output_data.csv  data/model_2675_output_data.csv
data/model_1676_output_data.csv  data/model_2676_output_data.csv
data/model_1677_output_data.csv  data/model_2677_output_data.csv
data/model_1678_output_data.csv  data/model_2678_output_data.csv
data/model_1679_output_data.csv  data/model_2679_output_data.csv
data/model_1680_output_data.csv  data/model_2680_output_data.csv
data/model_1681_output_data.csv  data/model_2681_output_data.csv
data/model_1682_output_data.csv  data/model_2682_output_data.csv
data/model_1683_output_data.csv  data/model_2683_output_data.csv
data/model_1684_output_data.csv  data/model_2684_output_data.csv
data/model_1685_output_data.csv  data/model_2685_output_data.csv
data/model_1686_output_data.csv  data/model_2686_output_data.csv
data/model_1687_output_data.csv  data/model_2687_output_data.csv
data/model_1688_output_data.csv  data/model_2688_output_data.csv
data/model_1689_output_data.csv  data/model_2689_output_data.csv
data/model_1690_output_data.csv  data/model_2690_output_data.csv
data/model_1691_output_data.csv  data/model_2691_output_data.csv
data/model_1692_output_data.csv  data/model_2692_output_data.csv
data/model_1693_output_data.csv  data/model_2693_output_data.csv
data/model_1694_output_data.csv  data/model_2694_output_data.csv
data/model_1695_output_data.csv  data/model_2695_output_data.csv
data/model_1696_output_data.csv  data/model_2696_output_data.csv
data/model_1697_output_data.csv  data/model_2697_output_data.csv
data/model_1698_output_data.csv  data/model_2698_output_data.csv
data/model_1699_output_data.csv  data/model_2699_output_data.csv
data/model_1700_output_data.csv  data/model_2700_output_data.csv
data/model_1701_output_data.csv  data/model_2701_output_data.csv
data/model_1702_output_data.csv  data/model_2702_output_data.csv
data/model_1703_output_data.csv  data/model_2703_output_data.csv
data/model_1704_output_data.csv  data/model_2704_output_data.csv
data/model_1705_output_data.csv  data/model_2705_output_data.csv
data/model_1706_output_data.csv  data/model_2706_output_data.csv
data/model_1707_output_data.csv  data/model_2707_output_data.csv
data/model_1708_output_data.csv  data/model_2708_output_data.csv
data/model_1709_output_data.csv  data/model_2709_output_data.csv
data/model_1710_output_data.csv  data/model_2710_output_data.csv
data/model_1711_output_data.csv  data/model_2711_output_data.csv
data/model_1712_output_data.csv  data/model_2712_output_data.csv
data/model_1713_output_data.csv  data/model_2713_output_data.csv
data/model_1714_output_data.csv  data/model_2714_output_data.csv
data/model_1715_output_data.csv  data/model_2715_output_data.csv
data/model_1716_output_data.csv  data/model_2716_output_data.csv
data/model_1717_output_data.csv  data/model_2717_output_data.csv
data/model_1718_output_data.csv  data/model_2718_output_data.csv
data/model_1719_output_data.csv  data/model_2719_output_data.csv
data/model_1720_output_data.csv  data/model_2720_output_data.csv
data/model_1721_output_data.csv  data/model_2721_output_data.csv
data/model_1722_output_data.csv  data/model_2722_output_data.csv
data/model_1723_output_data.csv  data/model_2723_output_data.csv
data/model_1724_output_data.csv  data/model_2724_output_data.csv
data/model_1725_output_data.csv  data/model_2725_output_data.csv
data/model_1726_output_data.csv  data/model_2726_output_data.csv
data/model_1727_output_data.csv  data/model_2727_output_data.csv
data/model_1728_output_data.csv  data/model_2728_output_data.csv
data/model_1729_output_data.csv  data/model_2729_output_data.csv
data/model_1730_output_data.csv  data/model_2730_output_data.csv
data/model_1731_output_data.csv  data/model_2731_output_data.csv
data/model_1732_output_data.csv  data/model_2732_output_data.csv
data/model_1733_output_data.csv  data/model_2733_output_data.csv
data/model_1734_output_data.csv  data/model_2734_output_data.csv
data/model_1735_output_data.csv  data/model_2735_output_data.csv
data/model_1736_output_data.csv  data/model_2736_output_data.csv
data/model_1737_output_data.csv  data/model_2737_output_data.csv
data/model_1738_output_data.csv  data/model_2738_output_data.csv
data/model_1739_output_data.csv  data/model_2739_output_data.csv
data/model_1740_output_data.csv  data/model_2740_output_data.csv
data/model_1741_output_data.csv  data/model_2741_output_data.csv
data/model_1742_output_data.csv  data/model_2742_output_data.csv
data/model_1743_output_data.csv  data/model_2743_output_data.csv
data/model_1744_output_data.csv  data/model_2744_output_data.csv
data/model_1745_output_data.csv  data/model_2745_output_data.csv
data/model_1746_output_data.csv  data/model_2746_output_data.csv
data/model_1747_output_data.csv  data/model_2747_output_data.csv
data/model_1748_output_data.csv  data/model_2748_output_data.csv
data/model_1749_output_data.csv  data/model_2749_output_data.csv
data/model_1750_output_data.csv  data/model_2750_output_data.csv
data/model_1751_output_data.csv  data/model_2751_output_data.csv
data/model_1752_output_data.csv  data/model_2752_output_data.csv
data/model_1753_output_data.csv  data/model_2753_output_data.csv
data/model_1754_output_data.csv  data/model_2754_output_data.csv
data/model_1755_output_data.csv  data/model_2755_output_data.csv
data/model_1756_output_data.csv  data/model_2756_output_data.csv
data/model_1757_output_data.csv  data/model_2757_output_data.csv
data/model_1758_output_data.csv  data/model_2758_output_data.csv
data/model_1759_output_data.csv  data/model_2759_output_data.csv
data/model_1760_output_data.csv  data/model_2760_output_data.csv
data/model_1761_output_data.csv  data/model_2761_output_data.csv
data/model_1762_output_data.csv  data/model_2762_output_data.csv
data/model_1763_output_data.csv  data/model_2763_output_data.csv
data/model_1764_output_data.csv  data/model_2764_output_data.csv
data/model_1765_output_data.csv  data/model_2765_output_data.csv
data/model_1766_output_data.csv  data/model_2766_output_data.csv
data/model_1767_output_data.csv  data/model_2767_output_data.csv
data/model_1768_output_data.csv  data/model_2768_output_data.csv
data/model_1769_output_data.csv  data/model_2769_output_data.csv
data/model_1770_output_data.csv  data/model_2770_output_data.csv
data/model_1771_output_data.csv  data/model_2771_output_data.csv
data/model_1772_output_data.csv  data/model_2772_output_data.csv
data/model_1773_output_data.csv  data/model_2773_output_data.csv
data/model_1774_output_data.csv  data/model_2774_output_data.csv
data/model_1775_output_data.csv  data/model_2775_output_data.csv
data/model_1776_output_data.csv  data/model_2776_output_data.csv
data/model_1777_output_data.csv  data/model_2777_output_data.csv
data/model_1778_output_data.csv  data/model_2778_output_data.csv
data/model_1779_output_data.csv  data/model_2779_output_data.csv
data/model_1780_output_data.csv  data/model_2780_output_data.csv
data/model_1781_output_data.csv  data/model_2781_output_data.csv
data/model_1782_output_data.csv  data/model_2782_output_data.csv
data/model_1783_output_data.csv  data/model_2783_output_data.csv
data/model_1784_output_data.csv  data/model_2784_output_data.csv
data/model_1785_output_data.csv  data/model_2785_output_data.csv
data/model_1786_output_data.csv  data/model_2786_output_data.csv
data/model_1787_output_data.csv  data/model_2787_output_data.csv
data/model_1788_output_data.csv  data/model_2788_output_data.csv
data/model_1789_output_data.csv  data/model_2789_output_data.csv
data/model_1790_output_data.csv  data/model_2790_output_data.csv
data/model_1791_output_data.csv  data/model_2791_output_data.csv
data/model_1792_output_data.csv  data/model_2792_output_data.csv
data/model_1793_output_data.csv  data/model_2793_output_data.csv
data/model_1794_output_data.csv  data/model_2794_output_data.csv
data/model_1795_output_data.csv  data/model_2795_output_data.csv
data/model_1796_output_data.csv  data/model_2796_output_data.csv
data/model_1797_output_data.csv  data/model_2797_output_data.csv
data/model_1798_output_data.csv  data/model_2798_output_data.csv
data/model_1799_output_data.csv  data/model_2799_output_data.csv
data/model_1800_output_data.csv  data/model_2800_output_data.csv
data/model_1801_output_data.csv  data/model_2801_output_data.csv
data/model_1802_output_data.csv  data/model_2802_output_data.csv
data/model_1803_output_data.csv  data/model_2803_output_data.csv
data/model_1804_output_data.csv  data/model_2804_output_data.csv
data/model_1805_output_data.csv  data/model_2805_output_data.csv
data/model_1806_output_data.csv  data/model_2806_output_data.csv
data/model_1807_output_data.csv  data/model_2807_output_data.csv
data/model_1808_output_data.csv  data/model_2808_output_data.csv
data/model_1809_output_data.csv  data/model_2809_output_data.csv
data/model_1810_output_data.csv  data/model_2810_output_data.csv
data/model_1811_output_data.csv  data/model_2811_output_data.csv
data/model_1812_output_data.csv  data/model_2812_output_data.csv
data/model_1813_output_data.csv  data/model_2813_output_data.csv
data/model_1814_output_data.csv  data/model_2814_output_data.csv
data/model_1815_output_data.csv  data/model_2815_output_data.csv
data/model_1816_output_data.csv  data/model_2816_output_data.csv
data/model_1817_output_data.csv  data/model_2817_output_data.csv
data/model_1818_output_data.csv  data/model_2818_output_data.csv
data/model_1819_output_data.csv  data/model_2819_output_data.csv
data/model_1820_output_data.csv  data/model_2820_output_data.csv
data/model_1821_output_data.csv  data/model_2821_output_data.csv
data/model_1822_output_data.csv  data/model_2822_output_data.csv
data/model_1823_output_data.csv  data/model_2823_output_data.csv
data/model_1824_output_data.csv  data/model_2824_output_data.csv
data/model_1825_output_data.csv  data/model_2825_output_data.csv
data/model_1826_output_data.csv  data/model_2826_output_data.csv
data/model_1827_output_data.csv  data/model_2827_output_data.csv
data/model_1828_output_data.csv  data/model_2828_output_data.csv
data/model_1829_output_data.csv  data/model_2829_output_data.csv
data/model_1830_output_data.csv  data/model_2830_output_data.csv
data/model_1831_output_data.csv  data/model_2831_output_data.csv
data/model_1832_output_data.csv  data/model_2832_output_data.csv
data/model_1833_output_data.csv  data/model_2833_output_data.csv
data/model_1834_output_data.csv  data/model_2834_output_data.csv
data/model_1835_output_data.csv  data/model_2835_output_data.csv
data/model_1836_output_data.csv  data/model_2836_output_data.csv
data/model_1837_output_data.csv  data/model_2837_output_data.csv
data/model_1838_output_data.csv  data/model_2838_output_data.csv
data/model_1839_output_data.csv  data/model_2839_output_data.csv
data/model_1840_output_data.csv  data/model_2840_output_data.csv
data/model_1841_output_data.csv  data/model_2841_output_data.csv
data/model_1842_output_data.csv  data/model_2842_output_data.csv
data/model_1843_output_data.csv  data/model_2843_output_data.csv
data/model_1844_output_data.csv  data/model_2844_output_data.csv
data/model_1845_output_data.csv  data/model_2845_output_data.csv
data/model_1846_output_data.csv  data/model_2846_output_data.csv
data/model_1847_output_data.csv  data/model_2847_output_data.csv
data/model_1848_output_data.csv  data/model_2848_output_data.csv
data/model_1849_output_data.csv  data/model_2849_output_data.csv
data/model_1850_output_data.csv  data/model_2850_output_data.csv
data/model_1851_output_data.csv  data/model_2851_output_data.csv
data/model_1852_output_data.csv  data/model_2852_output_data.csv
data/model_1853_output_data.csv  data/model_2853_output_data.csv
data/model_1854_output_data.csv  data/model_2854_output_data.csv
data/model_1855_output_data.csv  data/model_2855_output_data.csv
data/model_1856_output_data.csv  data/model_2856_output_data.csv
data/model_1857_output_data.csv  data/model_2857_output_data.csv
data/model_1858_output_data.csv  data/model_2858_output_data.csv
data/model_1859_output_data.csv  data/model_2859_output_data.csv
data/model_1860_output_data.csv  data/model_2860_output_data.csv
data/model_1861_output_data.csv  data/model_2861_output_data.csv
data/model_1862_output_data.csv  data/model_2862_output_data.csv
data/model_1863_output_data.csv  data/model_2863_output_data.csv
data/model_1864_output_data.csv  data/model_2864_output_data.csv
data/model_1865_output_data.csv  data/model_2865_output_data.csv
data/model_1866_output_data.csv  data/model_2866_output_data.csv
data/model_1867_output_data.csv  data/model_2867_output_data.csv
data/model_1868_output_data.csv  data/model_2868_output_data.csv
data/model_1869_output_data.csv  data/model_2869_output_data.csv
data/model_1870_output_data.csv  data/model_2870_output_data.csv
data/model_1871_output_data.csv  data/model_2871_output_data.csv
data/model_1872_output_data.csv  data/model_2872_output_data.csv
data/model_1873_output_data.csv  data/model_2873_output_data.csv
data/model_1874_output_data.csv  data/model_2874_output_data.csv
data/model_1875_output_data.csv  data/model_2875_output_data.csv
data/model_1876_output_data.csv  data/model_2876_output_data.csv
data/model_1877_output_data.csv  data/model_2877_output_data.csv
data/model_1878_output_data.csv  data/model_2878_output_data.csv
data/model_1879_output_data.csv  data/model_2879_output_data.csv
data/model_1880_output_data.csv  data/model_2880_output_data.csv
data/model_1881_output_data.csv  data/model_2881_output_data.csv
data/model_1882_output_data.csv  data/model_2882_output_data.csv
data/model_1883_output_data.csv  data/model_2883_output_data.csv
data/model_1884_output_data.csv  data/model_2884_output_data.csv
data/model_1885_output_data.csv  data/model_2885_output_data.csv
data/model_1886_output_data.csv  data/model_2886_output_data.csv
data/model_1887_output_data.csv  data/model_2887_output_data.csv
data/model_1888_output_data.csv  data/model_2888_output_data.csv
data/model_1889_output_data.csv  data/model_2889_output_data.csv
data/model_1890_output_data.csv  data/model_2890_output_data.csv
data/model_1891_output_data.csv  data/model_2891_output_data.csv
data/model_1892_output_data.csv  data/model_2892_output_data.csv
data/model_1893_output_data.csv  data/model_2893_output_data.csv
data/model_1894_output_data.csv  data/model_2894_output_data.csv
data/model_1895_output_data.csv  data/model_2895_output_data.csv
data/model_1896_output_data.csv  data/model_2896_output_data.csv
data/model_1897_output_data.csv  data/model_2897_output_data.csv
data/model_1898_output_data.csv  data/model_2898_output_data.csv
data/model_1899_output_data.csv  data/model_2899_output_data.csv
data/model_1900_output_data.csv  data/model_2900_output_data.csv
data/model_1901_output_data.csv  data/model_2901_output_data.csv
data/model_1902_output_data.csv  data/model_2902_output_data.csv
data/model_1903_output_data.csv  data/model_2903_output_data.csv
data/model_1904_output_data.csv  data/model_2904_output_data.csv
data/model_1905_output_data.csv  data/model_2905_output_data.csv
data/model_1906_output_data.csv  data/model_2906_output_data.csv
data/model_1907_output_data.csv  data/model_2907_output_data.csv
data/model_1908_output_data.csv  data/model_2908_output_data.csv
data/model_1909_output_data.csv  data/model_2909_output_data.csv
data/model_1910_output_data.csv  data/model_2910_output_data.csv
data/model_1911_output_data.csv  data/model_2911_output_data.csv
data/model_1912_output_data.csv  data/model_2912_output_data.csv
data/model_1913_output_data.csv  data/model_2913_output_data.csv
data/model_1914_output_data.csv  data/model_2914_output_data.csv
data/model_1915_output_data.csv  data/model_2915_output_data.csv
data/model_1916_output_data.csv  data/model_2916_output_data.csv
data/model_1917_output_data.csv  data/model_2917_output_data.csv
data/model_1918_output_data.csv  data/model_2918_output_data.csv
data/model_1919_output_data.csv  data/model_2919_output_data.csv
data/model_1920_output_data.csv  data/model_2920_output_data.csv
data/model_1921_output_data.csv  data/model_2921_output_data.csv
data/model_1922_output_data.csv  data/model_2922_output_data.csv
data/model_1923_output_data.csv  data/model_2923_output_data.csv
data/model_1924_output_data.csv  data/model_2924_output_data.csv
data/model_1925_output_data.csv  data/model_2925_output_data.csv
data/model_1926_output_data.csv  data/model_2926_output_data.csv
data/model_1927_output_data.csv  data/model_2927_output_data.csv
data/model_1928_output_data.csv  data/model_2928_output_data.csv
data/model_1929_output_data.csv  data/model_2929_output_data.csv
data/model_1930_output_data.csv  data/model_2930_output_data.csv
data/model_1931_output_data.csv  data/model_2931_output_data.csv
data/model_1932_output_data.csv  data/model_2932_output_data.csv
data/model_1933_output_data.csv  data/model_2933_output_data.csv
data/model_1934_output_data.csv  data/model_2934_output_data.csv
data/model_1935_output_data.csv  data/model_2935_output_data.csv
data/model_1936_output_data.csv  data/model_2936_output_data.csv
data/model_1937_output_data.csv  data/model_2937_output_data.csv
data/model_1938_output_data.csv  data/model_2938_output_data.csv
data/model_1939_output_data.csv  data/model_2939_output_data.csv
data/model_1940_output_data.csv  data/model_2940_output_data.csv
data/model_1941_output_data.csv  data/model_2941_output_data.csv
data/model_1942_output_data.csv  data/model_2942_output_data.csv
data/model_1943_output_data.csv  data/model_2943_output_data.csv
data/model_1944_output_data.csv  data/model_2944_output_data.csv
data/model_1945_output_data.csv  data/model_2945_output_data.csv
data/model_1946_output_data.csv  data/model_2946_output_data.csv
data/model_1947_output_data.csv  data/model_2947_output_data.csv
data/model_1948_output_data.csv  data/model_2948_output_data.csv
data/model_1949_output_data.csv  data/model_2949_output_data.csv
data/model_1950_output_data.csv  data/model_2950_output_data.csv
data/model_1951_output_data.csv  data/model_2951_output_data.csv
data/model_1952_output_data.csv  data/model_2952_output_data.csv
data/model_1953_output_data.csv  data/model_2953_output_data.csv
data/model_1954_output_data.csv  data/model_2954_output_data.csv
data/model_1955_output_data.csv  data/model_2955_output_data.csv
data/model_1956_output_data.csv  data/model_2956_output_data.csv
data/model_1957_output_data.csv  data/model_2957_output_data.csv
data/model_1958_output_data.csv  data/model_2958_output_data.csv
data/model_1959_output_data.csv  data/model_2959_output_data.csv
data/model_1960_output_data.csv  data/model_2960_output_data.csv
data/model_1961_output_data.csv  data/model_2961_output_data.csv
data/model_1962_output_data.csv  data/model_2962_output_data.csv
data/model_1963_output_data.csv  data/model_2963_output_data.csv
data/model_1964_output_data.csv  data/model_2964_output_data.csv
data/model_1965_output_data.csv  data/model_2965_output_data.csv
data/model_1966_output_data.csv  data/model_2966_output_data.csv
data/model_1967_output_data.csv  data/model_2967_output_data.csv
data/model_1968_output_data.csv  data/model_2968_output_data.csv
data/model_1969_output_data.csv  data/model_2969_output_data.csv
data/model_1970_output_data.csv  data/model_2970_output_data.csv
data/model_1971_output_data.csv  data/model_2971_output_data.csv
data/model_1972_output_data.csv  data/model_2972_output_data.csv
data/model_1973_output_data.csv  data/model_2973_output_data.csv
data/model_1974_output_data.csv  data/model_2974_output_data.csv
data/model_1975_output_data.csv  data/model_2975_output_data.csv
data/model_1976_output_data.csv  data/model_2976_output_data.csv
data/model_1977_output_data.csv  data/model_2977_output_data.csv
data/model_1978_output_data.csv  data/model_2978_output_data.csv
data/model_1979_output_data.csv  data/model_2979_output_data.csv
data/model_1980_output_data.csv  data/model_2980_output_data.csv
data/model_1981_output_data.csv  data/model_2981_output_data.csv
data/model_1982_output_data.csv  data/model_2982_output_data.csv
data/model_1983_output_data.csv  data/model_2983_output_data.csv
data/model_1984_output_data.csv  data/model_2984_output_data.csv
data/model_1985_output_data.csv  data/model_2985_output_data.csv
data/model_1986_output_data.csv  data/model_2986_output_data.csv
data/model_1987_output_data.csv  data/model_2987_output_data.csv
data/model_1988_output_data.csv  data/model_2988_output_data.csv
data/model_1989_output_data.csv  data/model_2989_output_data.csv
data/model_1990_output_data.csv  data/model_2990_output_data.csv
data/model_1991_output_data.csv  data/model_2991_output_data.csv
data/model_1992_output_data.csv  data/model_2992_output_data.csv
data/model_1993_output_data.csv  data/model_2993_output_data.csv
data/model_1994_output_data.csv  data/model_2994_output_data.csv
data/model_1995_output_data.csv  data/model_2995_output_data.csv
data/model_1996_output_data.csv  data/model_2996_output_data.csv
data/model_1997_output_data.csv  data/model_2997_output_data.csv
data/model_1998_output_data.csv  data/model_2998_output_data.csv
data/model_1999_output_data.csv  data/model_2999_output_data.csv

Here is an example of the various model-generated datasets. Each model increases the stratigraphic layer thickness by 10 centimeters (0.01 m), and the models above show what the expected radar reflections would look like, given the input parameters.

cd data

/home/abraeley/Downloads/abraeley.github.io-main/data

Validating the Data & Exploratory Data Analysis

If I use the distance equation shown above to convert the time to get radar return signals to depth/distance, it becomes clear that this data needs to be cleaned further:

model1000 = pd.read_csv('model_1000_output_data.csv', sep=",")
model1000["Distance"] = (model1000["Time (s)"]*(3e8))/(2*np.sqrt(3.1))
model1000.head(),model1000.tail()

(   Time (s)  power (dB)  amplitude (real)  amplitude (imag)     Distance
 0 -0.000043  -58.708651     -3.754318e-09      2.807403e-10 -3620.756693
 1 -0.000042  -58.848845      3.693893e-09     -2.804356e-10 -3619.052407
 2 -0.000042  -58.934609     -3.661016e-09      2.282432e-10 -3617.348120
 3 -0.000042  -58.868730      3.692362e-09     -1.651007e-10 -3615.643834
 4 -0.000042  -58.671926     -3.777640e-09      1.533726e-10 -3613.939547,
       Time (s)  power (dB)  amplitude (real)  amplitude (imag)     Distance
 4245  0.000042  -58.924782      3.661466e-09     -2.815716e-10  3613.939547
 4246  0.000042  -58.975319     -3.645935e-09      1.917198e-10  3615.643834
 4247  0.000042  -58.839233      3.705903e-09     -1.420481e-10  3617.348120
 4248  0.000042  -58.681094     -3.773148e-09      1.652132e-10  3619.052407
 4249  0.000043  -58.630476      3.791886e-09     -2.297088e-10  3620.756693)

Firstly, I should not have negative distances. Secondly, I set all of the models to have an approximate depth of 2000 meters. It is an artifact of the 1D SHARAD Simulator that extra data is created "outside" the bounds of the model. In order to avoid confusion (for us, as well as for the neural network) this data needs to be ignored/removed. Below I import several models and calculate the indeces for the surface of the ice, as well as for the basal reflector at the bottom of the ice. Then, the plots contain only the information pertinent to us:

cd /home/abraeley/Downloads/abraeley.github.io-main/data

/home/abraeley/Downloads/abraeley.github.io-main/data

model1000 = pd.read_csv('model_1000_output_data.csv', sep=",")

model1300 = pd.read_csv('model_1300_output_data.csv', sep=",")

model1600 = pd.read_csv('model_1600_output_data.csv', sep=",")

model1900 = pd.read_csv('model_1900_output_data.csv', sep=",")

model2100 = pd.read_csv('model_2100_output_data.csv', sep=",")

model2400 = pd.read_csv('model_2400_output_data.csv', sep=",")

model2700 = pd.read_csv('model_2700_output_data.csv', sep=",")

model2999 = pd.read_csv('model_2999_output_data.csv', sep=",")

# Clean data (remove negative times)

# Model1000
model1000["Distance"] = (model1000["Time (s)"]*(3e8))/(2*np.sqrt(3.1))
surfaceIndex = int(model1000.loc[model1000["Distance"] >= 0].index[0])
basalIndex = int(model1000.loc[model1000["Distance"] >= 2000].index[0])

model1000 = model1000.loc[surfaceIndex:basalIndex,]

# Model 1300
model1300["Distance"] = (model1300["Time (s)"]*(3e8))/(2*np.sqrt(3.1))
surfaceIndex = int(model1300.loc[model1300["Distance"] >= 0].index[0])
basalIndex = int(model1300.loc[model1300["Distance"] >= 2000].index[0])

model1300 = model1300.loc[surfaceIndex:basalIndex,]

# Model 1600
model1600["Distance"] = (model1600["Time (s)"]*(3e8))/(2*np.sqrt(3.1))
surfaceIndex = int(model1600.loc[model1600["Distance"] >= 0].index[0])
basalIndex = int(model1600.loc[model1600["Distance"] >= 2000].index[0])

model1600 = model1600.loc[surfaceIndex:basalIndex,]

# Model 1900
model1900["Distance"] = (model1900["Time (s)"]*(3e8))/(2*np.sqrt(3.1))
surfaceIndex = int(model1900.loc[model1900["Distance"] >= 0].index[0])
basalIndex = int(model1900.loc[model1900["Distance"] >= 2000].index[0])

model1900 = model1900.loc[surfaceIndex:basalIndex,]

# Model 2100
model2100["Distance"] = (model2100["Time (s)"]*(3e8))/(2*np.sqrt(3.1))
surfaceIndex = int(model2100.loc[model2100["Distance"] >= 0].index[0])
basalIndex = int(model2100.loc[model2100["Distance"] >= 2000].index[0])

model2100 = model2100.loc[surfaceIndex:basalIndex,]

# Model 2400
model2400["Distance"] = (model2400["Time (s)"]*(3e8))/(2*np.sqrt(3.1))
surfaceIndex = int(model2400.loc[model2400["Distance"] >= 0].index[0])
basalIndex = int(model2400.loc[model2400["Distance"] >= 2000].index[0])

model2400 = model2400.loc[surfaceIndex:basalIndex,]

# Model 2700
model2700["Distance"] = (model2700["Time (s)"]*(3e8))/(2*np.sqrt(3.1))
surfaceIndex = int(model2700.loc[model2700["Distance"] >= 0].index[0])
basalIndex = int(model2700.loc[model2700["Distance"] >= 2000].index[0])

model2700 = model2700.loc[surfaceIndex:basalIndex,]

# Model 2999
model2999["Distance"] = (model2999["Time (s)"]*(3e8))/(2*np.sqrt(3.1))
surfaceIndex = int(model2999.loc[model2999["Distance"] >= 0].index[0])
basalIndex = int(model2999.loc[model2999["Distance"] >= 2000].index[0])

model2999 = model2999.loc[surfaceIndex:basalIndex,]


# Plotting each of the above models
fig, axes = plt.subplots(2, 4, figsize=(12,16))
fig.suptitle('Model-Generated Data (15-25 MHz)', fontsize=16)

mod1000Plot = model1000.plot(ax=axes[0,0], x='power (dB)', y='Time (s)', xlabel="Power (dB)", ylabel="Time (s)", legend=False)
mod1000Plot.set_ylim(0, 0.0000240)
mod1000Plot.set_xlim(-60, 5)
mod1000Plot.invert_yaxis()
mod1000Plot.set_title("Model 1000 (10-m Intervals)", fontsize=6.5)
mod1000Plot.axhline(y=1.5e-5,color='r',linestyle='-')

mod1300Plot = model1300.plot(ax=axes[0,1], x='power (dB)', y='Time (s)', xlabel="Power (dB)", ylabel="", legend=False)
mod1300Plot.set_ylim(0, 0.0000240)
mod1300Plot.set_xlim(-60, 5)
mod1300Plot.invert_yaxis()
mod1300Plot.set_title("Model 1300 (13 m Layers)", fontsize=6.5)
mod1300Plot.axhline(y=0.8e-5,color='r',linestyle='-')


mod1600Plot = model1600.plot(ax=axes[0,2], x='power (dB)', y='Time (s)', xlabel="Power (dB)", ylabel="", legend=False)
mod1600Plot.set_ylim(0, 0.0000240)
mod1600Plot.set_xlim(-60, 5)
mod1600Plot.invert_yaxis()
mod1600Plot.set_title("Model 1600 (16 m Layers)", fontsize=6.5)
mod1600Plot.axhline(y=1.1e-5,color='r',linestyle='-')


mod1900Plot = model1900.plot(ax=axes[0,3], x='power (dB)', y='Time (s)', xlabel="Power (dB)", ylabel="", legend=False)
mod1900Plot.set_ylim(0, 0.0000240)
mod1900Plot.set_xlim(-60, 5)
mod1900Plot.invert_yaxis()
mod1900Plot.set_title("Model 1900 (19 m Layers)", fontsize=6.5)
mod1900Plot.axhline(y=1.15e-5,color='r',linestyle='-')


mod2100Plot = model2100.plot(ax=axes[1,0], x='power (dB)', y='Time (s)', xlabel="Power (dB)", ylabel="Time (s)", legend=False)
mod2100Plot.set_ylim(0, 0.0000240)
mod2100Plot.set_xlim(-60, 5)
mod2100Plot.invert_yaxis()
mod2100Plot.set_title("Model 2100 (21 m Layers)", fontsize=6.5)
mod2100Plot.axhline(y=1.2e-5,color='r',linestyle='-')


mod2400Plot = model2400.plot(ax=axes[1,1], x='power (dB)', y='Time (s)', xlabel="Power (dB)", ylabel="", legend=False)
mod2400Plot.set_ylim(0, 0.0000240)
mod2400Plot.set_xlim(-60, 5)
mod2400Plot.invert_yaxis()
mod2400Plot.set_title("Model 2400 (24 m Layers)", fontsize=6.5)
mod2400Plot.axhline(y=1.4e-5,color='r',linestyle='-')


mod2700Plot = model2700.plot(ax=axes[1,2], x='power (dB)', y='Time (s)', xlabel="Power (dB)", ylabel="", legend=False)
mod2700Plot.set_ylim(0, 0.0000240)
mod2700Plot.set_xlim(-60, 5)
mod2700Plot.invert_yaxis()
mod2700Plot.set_title("Model 2700 (27 m Layers)", fontsize=6.5)
mod2700Plot.axhline(y=1.6e-5,color='r',linestyle='-')


mod2999Plot = model2999.plot(ax=axes[1,3], x='power (dB)', y='Time (s)', xlabel="Power (dB)", ylabel="", legend=False)
mod2999Plot.set_ylim(0, 0.0000240)
mod2999Plot.set_xlim(-60, 5)
mod2999Plot.invert_yaxis()
mod2999Plot.set_title("Model 2999 (~30 m Layers)", fontsize=6.5)
mod2999Plot.axhline(y=1.8e-5,color='r',linestyle='-')

<matplotlib.lines.Line2D at 0x7f5b39233940>

cd /home/abraeley/Downloads/abraeley.github.io-main/data

/home/abraeley/Downloads/abraeley.github.io-main/data/model1600

# Plotting each of the above models
fig, ax = plt.subplots(figsize=(18,24))
fig.suptitle('Model-Generated Data (15-25 MHz)', fontsize=16)

model1600 = pd.read_csv('model_1600_output_data.csv', sep=",")

# Model 1600
model1600["Distance"] = (model1600["Time (s)"]*(3e8))/(2*np.sqrt(3.1))
surfaceIndex = int(model1600.loc[model1600["Distance"] >= 0].index[0])
basalIndex = int(model1600.loc[model1600["Distance"] >= 2000].index[0])

model1600 = model1600.loc[surfaceIndex:basalIndex,]

# Plotting each of the above models
#fig, axes = plt.subplots(figsize=(12,16))
#fig.suptitle('Model-Generated Data (15-25 MHz)', fontsize=16)

mod1600Plot = model1600.plot(ax=ax, x='power (dB)', y='Time (s)', xlabel="Power (dB)", color='g', ylabel="", label='Combined (15-25 MHz)', legend=True)
#mod1600Plot.set_ylim(0, 0.0000240)
#mod1600Plot.set_xlim(-60, 5)
#mod1600Plot.invert_yaxis()
#mod1600Plot.set_title("Model 1600 (16 m Layers)", fontsize=6.5)
#mod1600Plot.axhline(y=1.1e-5,color='r',linestyle='-')



model1600_L = pd.read_csv('model_1600_L_output_data.csv', sep=",")

# Model 1600
model1600_L["Distance"] = (model1600_L["Time (s)"]*(3e8))/(2*np.sqrt(3.1))
surfaceIndex = int(model1600_L.loc[model1600_L["Distance"] >= 0].index[0])
basalIndex = int(model1600_L.loc[model1600_L["Distance"] >= 2000].index[0])

model1600_L = model1600_L.loc[surfaceIndex:basalIndex,]

mod1600Plot = model1600_L.plot(ax=ax, x='power (dB)', y='Time (s)', xlabel="Power (dB)", color='r', ylabel="", label='Low (15-20 MHz)', legend=True)
#mod1600Plot.set_ylim(0, 0.0000240)
#mod1600Plot.set_xlim(-60, 5)
#mod1600Plot.invert_yaxis()
#mod1600Plot.set_title("Model L 1600 (16 m Layers)", fontsize=6.5)
#mod1600Plot.axhline(y=1.1e-5,color='r',linestyle='-')


model1600_H = pd.read_csv('model_1600_H_output_data.csv', sep=",")

# Model 1600
model1600_H["Distance"] = (model1600_H["Time (s)"]*(3e8))/(2*np.sqrt(3.1))
surfaceIndex = int(model1600_H.loc[model1600_H["Distance"] >= 0].index[0])
basalIndex = int(model1600_H.loc[model1600_H["Distance"] >= 2000].index[0])

model1600_H = model1600_H.loc[surfaceIndex:basalIndex,]

mod1600Plot = model1600_H.plot(ax=ax, x='power (dB)', y='Time (s)', xlabel="Power (dB)", color='b', ylabel="Time (s)", label='High (20-25 MHz)', legend=True)
mod1600Plot.set_ylim(0, 0.0000240)
mod1600Plot.set_xlim(-60, 5)
mod1600Plot.set_xlabel('power (dB)',fontsize=24)
mod1600Plot.set_ylabel('Time (s)',fontsize=24)
mod1600Plot.legend(fontsize=24)

mod1600Plot.invert_yaxis()
mod1600Plot.set_title("Model 1600 (16 m Layers)", fontsize=15)
mod1600Plot.axhline(y=1.1e-5,color='r',linestyle='-')

<matplotlib.lines.Line2D at 0x7fdd2822e160>

Models with 16-m spacing between layers, with the figures separated by subband grouping:

Models with 100-m spacing between layers, with the figures separated by subband grouping:

The above plots show the power (/reflections) versus time (/distance). Since the simulator is 1-dimensional, this is equivalent to making a power versus time figure directly from a radargram of real radar sounder data, using a column of pixels traversing down the radargram.

Horizontal lines are plotted in regions where a behavioral change can be seen in the radar reflection patterns. This change seems to be one where reflections begin to favor shorter-wavelength reflections, and longer wavelength noise. The general trend seems to be in favor of increasing visibility to radar as a function of increasing layer thickness. The bahavioral change does not come from "noise" as the model was given a noise floor od -101 dB (noise below -100 dB is ignored and not integrated into the model-generated data).

These seem to be some sort of radar "echo" that the lower-frequency subband is more sensitive to for some reason. So this EDA has been helpful for me to narrow in on what subset of the data would be perhaps more reliable to train the neural network off of.

I also plotted above two sets of three graphs showing a 16-meter layer spacing interval, and a 100-m interval respectively. Each of the sets has the combined 15-25 MHz bandwidth plot, as well as a lower frequency 15-20 MHz figure, and a higher frequency 20-25 MHz figure. Splitting the data up this way illustrates how much more sensitive the lower frequency subband is to the echoing.

To show that reflections are largely homogeneous across different layer-thickness regimes, the power values of the various reflections can be aggregated and plotted in a box plot:

boxFrame = pd.DataFrame()
boxFrame["Model 1000"] = model1000["power (dB)"]
boxFrame["Model 1300"] = model1300["power (dB)"]
boxFrame["Model 1600"] = model1600["power (dB)"]
boxFrame["Model 1900"] = model1900["power (dB)"]
boxFrame["Model 2100"] = model2100["power (dB)"]
boxFrame["Model 2400"] = model2400["power (dB)"]
boxFrame["Model 2700"] = model2700["power (dB)"]
boxFrame["Model 2999"] = model2999["power (dB)"]

plots = boxFrame.boxplot(grid=False, rot=45, fontsize=15) 
plots.set_ylabel("Power (dB)")
plots.set_title("Reflections Across Layer-Thickness Regimes")

Text(0.5, 1.0, 'Reflections Across Layer-Thickness Regimes')

Looking at the time versus power plots above, it seems as though the power of the reflections declines the deeper into the ice you go. To verify this I will compare some of the surface reflection power values to those at the base of the ice caps:

surfaceReflections = pd.DataFrame()
basalReflections = pd.DataFrame()

# For Model 1000 (10-m thick layers)
surfaceStart = int(model1000.loc[model1000["Distance"] >= 0].index[0])
surfaceEnd = int(model1000.loc[model1000["Distance"] >= 10].index[0])
basalStart = int(model1000.loc[model1000["Distance"] >= 1990].index[0])
basalEnd = int(model1000.loc[model1000["Distance"] >= 2000].index[0])

surfaceReflections["Model 1000"] = model1000["power (dB)"].loc[surfaceStart:surfaceEnd,]
basalReflections["Model 1000"] = model1000["power (dB)"].loc[basalStart:basalEnd,]

# For Model 1300 (13-m thick layers)
surfaceStart = int(model1300.loc[model1300["Distance"] >= 0].index[0])
surfaceEnd = int(model1300.loc[model1300["Distance"] >= 13].index[0])
basalStart = int(model1300.loc[model1300["Distance"] >= 1987].index[0])
basalEnd = int(model1300.loc[model1300["Distance"] >= 2000].index[0])

surfaceReflections["Model 1300"] = model1300["power (dB)"].loc[surfaceStart:surfaceEnd,]
basalReflections["Model 1300"] = model1300["power (dB)"].loc[basalStart:basalEnd,]

# For Model 1600 (16-m thick layers)
surfaceStart = int(model1600.loc[model1600["Distance"] >= 0].index[0])
surfaceEnd = int(model1600.loc[model1600["Distance"] >= 16].index[0])
basalStart = int(model1600.loc[model1600["Distance"] >= 1984].index[0])
basalEnd = int(model1600.loc[model1600["Distance"] >= 2000].index[0])

surfaceReflections["Model 1600"] = model1600["power (dB)"].loc[surfaceStart:surfaceEnd,]
basalReflections["Model 1600"] = model1600["power (dB)"].loc[basalStart:basalEnd,]

# For Model 1900 (19-m thick layers)
surfaceStart = int(model1900.loc[model1900["Distance"] >= 0].index[0])
surfaceEnd = int(model1900.loc[model1900["Distance"] >= 19].index[0])
basalStart = int(model1900.loc[model1900["Distance"] >= 1981].index[0])
basalEnd = int(model1900.loc[model1900["Distance"] >= 2000].index[0])

surfaceReflections["Model 1900"] = model1900["power (dB)"].loc[surfaceStart:surfaceEnd,]
basalReflections["Model 1900"] = model1900["power (dB)"].loc[basalStart:basalEnd,]

# For Model 2100 (21-m thick layers)
surfaceStart = int(model2100.loc[model2100["Distance"] >= 0].index[0])
surfaceEnd = int(model2100.loc[model2100["Distance"] >= 21].index[0])
basalStart = int(model2100.loc[model2100["Distance"] >= 1979].index[0])
basalEnd = int(model2100.loc[model2100["Distance"] >= 2000].index[0])

surfaceReflections["Model 2100"] = model2100["power (dB)"].loc[surfaceStart:surfaceEnd,]
basalReflections["Model 2100"] = model2100["power (dB)"].loc[basalStart:basalEnd,]

# For Model 2400 (24-m thick layers)
surfaceStart = int(model2400.loc[model2400["Distance"] >= 0].index[0])
surfaceEnd = int(model2400.loc[model2400["Distance"] >= 24].index[0])
basalStart = int(model2400.loc[model2400["Distance"] >= 1976].index[0])
basalEnd = int(model2400.loc[model2400["Distance"] >= 2000].index[0])

surfaceReflections["Model 2400"] = model2400["power (dB)"].loc[surfaceStart:surfaceEnd,]
basalReflections["Model 2400"] = model2400["power (dB)"].loc[basalStart:basalEnd,]

# For Model 2700 (27-m thick layers)
surfaceStart = int(model2700.loc[model2700["Distance"] >= 0].index[0])
surfaceEnd = int(model2700.loc[model2700["Distance"] >= 27].index[0])
basalStart = int(model2700.loc[model2700["Distance"] >= 1973].index[0])
basalEnd = int(model2700.loc[model2700["Distance"] >= 2000].index[0])

surfaceReflections["Model 2700"] = model2700["power (dB)"].loc[surfaceStart:surfaceEnd,]
basalReflections["Model 2700"] = model2700["power (dB)"].loc[basalStart:basalEnd,]

# For Model 2999 (~30-m thick layers)
surfaceStart = int(model2999.loc[model2999["Distance"] >= 0].index[0])
surfaceEnd = int(model2999.loc[model2999["Distance"] >= 30].index[0])
basalStart = int(model2999.loc[model2999["Distance"] >= 1970].index[0])
basalEnd = int(model2999.loc[model2999["Distance"] >= 2000].index[0])

surfaceReflections["Model 2999"] = model2999["power (dB)"].loc[surfaceStart:surfaceEnd,]
basalReflections["Model 2999"] = model2999["power (dB)"].loc[basalStart:basalEnd,]


surfacePlots = surfaceReflections.boxplot(grid=False, rot=45, fontsize=15) 
surfacePlots.set_ylabel("Power (dB)")
surfacePlots.set_title("Reflections")

basalPlots = basalReflections.boxplot(grid=False, rot=45, fontsize=15) 
basalPlots.set_ylabel("Power (dB)")

Text(0, 0.5, 'Power (dB)')

This agrees with the power versus time plots above. There is a clear distinction between the dispersion of power values at the surface reflections across all models, and their respective basal reflection power disperion. This is to be expected. As electromagnetic radiation hits a new interface (the icy surface), some power is reflected, some is absorbed, and some is transmitted. As the light/radiation transmits down through the ice, it will eventually encounter material with a new dielectric constant/permittivity value. This would be a new interface where we would get another instance of reflection, absorption, and then transmission. The more stratigraphic layers with distinct dielectric values, the more this will occur. With every instance, more energy is lost from the overall radar signal. This is radar attenuation.

This is good in one sense, and bad in another. It is good because the data produced by the models seem to follow the physics we expect. It is bad, however, because this means that the radar signal will attenuate (weaken) as a function of time/depth. There may therefore be a danger of the signal-to-noise ratio becoming too low, potentially complicating the ability to deconvolve stratigraphy beyond a certain point.

Deconvolving Martian Stratigraphy

Now that the data has been read in and processed, we can begin setting up the neural network. The tool that we will use for this work is going to be Scikit Learn's MLPClassifier (Multi-layer perceptron classifier), a form of neural network. This tool will take in a vertical column of pixels from a radargram image, which have reflection power values associated with them as you traverse down. Each pixel is one of the inputs to the neural network:

The output, at least for the initial work, will be to classify whether or not a given input pixel is a layer interface. Not all layer interfaces appear in a given power versus time plot, radargram, etc. Nor are all reflections layer interfaces (there are radar "echoes").

To analyze the results, I will be creating pairplots between the output variable and doing some statistics of the signal (number of readings X standard deviations above the mean in the series).

Assigning the training labels

Because the training data (model-generated data above) does not output in neat intervals in accordance with the assignment of "layer" interfaces, (i.e. many of the rows are at distances like "0.852143 meters"). If a layer is to be labelled at intervals of 10 meters, than this means I need to define when it is appropriate to label a row as a layer interface. To this end, I am going to arbitrarily use a round-up, round-down method. That is to say that if layer interfaces occur at 10-meter intervals, and there is a row at a distance of 9.47 meters, it will round down to 9.0 and not be labelled as a layer. If it is 9.53 however, it will round up to 10 and be labelled as a layer interface. This is an interim strategy to allow forward movement of this research, but should be further scrutinized and improved upon if possible.

Below I import my training labels (which includes both layer intervals, as well as associated dielectric constant values (eps) for expansion of this model in the future). I created these when I ran the shell script to iteratively run each of my models above:

cd model1600/

/home/abraeley/Downloads/abraeley.github.io-main/data/model1600

ls

model_1600_H_model.csv          model_1600_L_output_figure.png
model_1600_H_output_data.csv    model_1600_model.csv
model_1600_H_output_figure.png  model_1600_output_data.csv
model_1600_L_model.csv          model_1600_output_figure.png
model_1600_L_output_data.csv    test/

labels1000 = pd.read_csv('model_1000_model.csv', sep=",")
labels1300 = pd.read_csv('model_1300_model.csv', sep=",")
labels1600 = pd.read_csv('model_1600_model.csv', sep=",")
labels1900 = pd.read_csv('model_1900_model.csv', sep=",")
labels2100 = pd.read_csv('model_2100_model.csv', sep=",")
labels2400 = pd.read_csv('model_2400_model.csv', sep=",")
labels2700 = pd.read_csv('model_2700_model.csv', sep=",")
labels2999 = pd.read_csv('model_2999_model.csv', sep=",")
labels1300

	Depth (m)	eps
0	0.0	2.8
1	13.0	2.8
2	13.0	3.4
3	26.0	3.4
4	26.0	2.8
...	...	...
300	1950.0	2.8
301	1963.0	2.8
302	1963.0	3.4
303	1976.0	3.4
304	1976.0	2.8

305 rows × 2 columns

labels1600 = pd.read_csv('model_1600_model.csv', sep=",")
labels1600_L = pd.read_csv('model_1600_L_model.csv', sep=",")
labels1600_H = pd.read_csv('model_1600_H_model.csv', sep=",")

In order to assign the training labels I am: 1) Creating a new column "Layer Interface" to contain the label

2) Reading in the model_X_model.csv files for each repsective model. These files contain a column of for layers, and a column for a respective layer dielectric constant value.

3) Using a lambda function in order to find the depth of the first layer interface. This first depth is technically the difference between the first layer interface and the surface of the ice. Since the surface of the ice is zero m however, we can simply take the distance of the first layer interface to be the layer interval. The remaining intervals need to be calculated by using the "model_X_model.csv" output files that were generated when I ran the shell script above to generate the model data. Each time the 1D Simulator is run, it generates the output data file as well as the model_X_model.csv file, which essentially contains the input parameteres for the simulator: number of layers, their respective thicknesses and their respective dielectric constant values. By iterating down the rows of this file all traiing data can be correctly assigned to the models. As I have a distance column calculated already, we can go row by row to find values that fit the interval. Rather than looking for exact values I am rounding the rows up/down to their nearest integer. If the rounded integer is divisible by the layer interval distance, than it is labeled "True" for "true, this is a Layer Interface".

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import math

# If a distance is within 0.5 of a number divisible by whatever the layer thickness interval is, it is labelled as a layer interface row
model1000["Layer Interface"] = model1000["Distance"].apply(lambda x: True if round(x) % (labels1000["Depth (m)"][1]-labels1000["Depth (m)"][0]) == 0 else False) 
model1300["Layer Interface"] = model1300["Distance"].apply(lambda x: True if round(x) % (labels1300["Depth (m)"][1]-labels1300["Depth (m)"][0]) == 0 else False) 
model1600["Layer Interface"] = model1600["Distance"].apply(lambda x: True if round(x) % (labels1600["Depth (m)"][1]-labels1600["Depth (m)"][0]) == 0 else False) 
model1900["Layer Interface"] = model1900["Distance"].apply(lambda x: True if round(x) % (labels1900["Depth (m)"][1]-labels1900["Depth (m)"][0]) == 0 else False) 
model2100["Layer Interface"] = model2100["Distance"].apply(lambda x: True if round(x) % (labels2100["Depth (m)"][1]-labels2100["Depth (m)"][0]) == 0 else False) 
model2400["Layer Interface"] = model2400["Distance"].apply(lambda x: True if round(x) % (labels2400["Depth (m)"][1]-labels2400["Depth (m)"][0]) == 0 else False) 
model2700["Layer Interface"] = model2700["Distance"].apply(lambda x: True if round(x) % (labels2700["Depth (m)"][1]-labels2700["Depth (m)"][0]) == 0 else False) 
model2999["Layer Interface"] = model2999["Distance"].apply(lambda x: True if round(x) % (labels2999["Depth (m)"][1]-labels2999["Depth (m)"][0]) == 0 else False) 


model1300.head(20)

	Time (s)	power (dB)	amplitude (real)	amplitude (imag)	Distance	Layer Interface
2125	1.000235e-08	-0.147417	-1.666096e-06	1.993510e-06	0.852143	False
2126	3.000706e-08	-0.404372	-5.757337e-07	-2.455749e-06	2.556430	False
2127	5.001177e-08	-0.769617	2.211578e-06	9.787317e-07	4.260716	False
2128	7.001647e-08	-1.230902	-2.009123e-06	1.105904e-06	5.965003	False
2129	9.002118e-08	-1.781103	3.302092e-07	-2.127137e-06	7.669289	False
2130	1.100259e-07	-2.418547	1.365499e-06	1.461709e-06	9.373576	False
2131	1.300306e-07	-3.140816	-1.835281e-06	1.410067e-07	11.077862	False
2132	1.500353e-07	-3.935319	9.585032e-07	-1.379482e-06	12.782149	True
2133	1.700400e-07	-4.772496	4.087090e-07	1.469673e-06	14.486435	False
2134	1.900447e-07	-5.606803	-1.260546e-06	-5.755823e-07	16.190722	False
2135	2.100494e-07	-6.387526	1.147651e-06	-5.359235e-07	17.895008	False
2136	2.300541e-07	-7.075934	-3.150194e-07	1.126902e-06	19.599295	False
2137	2.500588e-07	-7.659519	-6.076298e-07	-9.098224e-07	21.303581	False
2138	2.700635e-07	-8.153616	1.026840e-06	1.177706e-07	23.007868	False
2139	2.900683e-07	-8.588442	-7.073594e-07	6.827410e-07	24.712154	False
2140	3.100730e-07	-8.989955	-9.381770e-08	-9.339930e-07	26.416441	True
2141	3.300777e-07	-9.368077	7.700690e-07	4.633204e-07	28.120727	False
2142	3.500824e-07	-9.721964	-7.900598e-07	3.468056e-07	29.825014	False
2143	3.700871e-07	-10.058237	1.473998e-07	-8.168679e-07	31.529300	False
2144	3.900918e-07	-10.401699	5.836262e-07	5.440492e-07	33.233587	False

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import math

model1600["Layer Interface"] = model1600["Distance"].apply(lambda x: True if round(x) % (labels1600["Depth (m)"][1]-labels1600["Depth (m)"][0]) == 0 else False) 

As shown above, for a layer interval of 13 meters (the interval for model1300), a distance of 12.782149 meters (row 2132) and a distance of 26.416441 meters (row 2140) are both recognized as being close enough to the known location of a stratigraphic layer, that they are labelled as true. It is hoped that the neural network will be able to build an association between the time, and respective power values such that it will be able to then correctly assign the locations of stratigraphic layers in the raw SHARAD radar sounder data.'

The complete figure for model1300 looks like this with the stratigraphy assigned in the correct place:

mod1300Plot = model1300.plot(x='power (dB)', y='Time (s)', xlabel="Power (dB)", ylabel="", legend=False, figsize=(6,10))
mod1300Plot.set_ylim(0, 0.0000240)
mod1300Plot.set_xlim(-60, 5)
mod1300Plot.invert_yaxis()
mod1300Plot.set_title("Model 1300 With Associated Stratigraphy")


model1300["Layer Interface"] = model1300["Distance"].apply(lambda x: True if round(x) % (labels1300["Depth (m)"][1]-labels1300["Depth (m)"][0]) == 0 else False) 

surfaceStart = int(model1300.loc[model1300["Distance"] >= 0].index[0])

count=0
for row in range(len(model1300)):
    if model1300["Layer Interface"].iloc[count] == True:
        #print(model1300["Distance"].iloc[count])
        mod1300Plot.axhline(y=model1300["Time (s)"].iloc[count],color='r',linestyle='-')
    count+=1
        

Methodology

This training data makes was scripted to automatically generate models which have preset layer boundaries at consistent intervals. This allows me to run the entire process from data generation, data processing, model integration of the data, labeling of the training data, as well as training of the neural network. A concern I have leading into this preliminary attempt to deconvolve the stratigraphy of the NPLD is that the neural network will recognize only the interval distance between layer interfaces (which is consistent for this initial run).

Furthermore, I will run the initial training sequence using a single model-generated dataset. This is for ease of confirming the pipeline itself and more training sets will rapidly be integrated into the

After validating the entire data pipeline through to the running of the neural network, I will begin reconstructing the pipeline itself to holistically integrate the entirety of the data I have generated. It will not be until this point that I hope for trully meaningful data-trained results.

Finally, in the future I will also want to integrate dielectric constants into the system, however I will first test this approach with layer interfaces only.

Training the Neural Network

cd /home/abraeley/Downloads/abraeley.github.io-main/neuralNetworkTest

/home/abraeley/Downloads/abraeley.github.io-main/neuralNetworkTest

ls

radar_FM1D_refMethod.py*  runModels.sh

# Set to run for a series of different layer sizes
# with a depth of 2000 m,
# modelCount set to 5 so the model name matches the size of layer interval in m,
# an iteration step size of 1 m,
# a starting layer size of 5 m,
# and the bandwidth to calculate for is the high freq sub-band (20-25 MHz).
# The singleModel parameter is set to 0 so it iterates up to the depth, creating a model for ever 1 m interval.
generateModels(2000, 5, 1, 5, 2, 0)


# This generates 1995 models (5 m layer intervals, up to a 2000 m interval size [with the total depth also being 2000 m]

ls

model_1000_H.txt  model_1451_H.txt  model_1901_H.txt  model_555_H.txt
model_1001_H.txt  model_1452_H.txt  model_1902_H.txt  model_556_H.txt
model_1002_H.txt  model_1453_H.txt  model_1903_H.txt  model_557_H.txt
model_1003_H.txt  model_1454_H.txt  model_1904_H.txt  model_558_H.txt
model_1004_H.txt  model_1455_H.txt  model_1905_H.txt  model_559_H.txt
model_1005_H.txt  model_1456_H.txt  model_1906_H.txt  model_55_H.txt
model_1006_H.txt  model_1457_H.txt  model_1907_H.txt  model_560_H.txt
model_1007_H.txt  model_1458_H.txt  model_1908_H.txt  model_561_H.txt
model_1008_H.txt  model_1459_H.txt  model_1909_H.txt  model_562_H.txt
model_1009_H.txt  model_145_H.txt   model_190_H.txt   model_563_H.txt
model_100_H.txt   model_1460_H.txt  model_1910_H.txt  model_564_H.txt
model_1010_H.txt  model_1461_H.txt  model_1911_H.txt  model_565_H.txt
model_1011_H.txt  model_1462_H.txt  model_1912_H.txt  model_566_H.txt
model_1012_H.txt  model_1463_H.txt  model_1913_H.txt  model_567_H.txt
model_1013_H.txt  model_1464_H.txt  model_1914_H.txt  model_568_H.txt
model_1014_H.txt  model_1465_H.txt  model_1915_H.txt  model_569_H.txt
model_1015_H.txt  model_1466_H.txt  model_1916_H.txt  model_56_H.txt
model_1016_H.txt  model_1467_H.txt  model_1917_H.txt  model_570_H.txt
model_1017_H.txt  model_1468_H.txt  model_1918_H.txt  model_571_H.txt
model_1018_H.txt  model_1469_H.txt  model_1919_H.txt  model_572_H.txt
model_1019_H.txt  model_146_H.txt   model_191_H.txt   model_573_H.txt
model_101_H.txt   model_1470_H.txt  model_1920_H.txt  model_574_H.txt
model_1020_H.txt  model_1471_H.txt  model_1921_H.txt  model_575_H.txt
model_1021_H.txt  model_1472_H.txt  model_1922_H.txt  model_576_H.txt
model_1022_H.txt  model_1473_H.txt  model_1923_H.txt  model_577_H.txt
model_1023_H.txt  model_1474_H.txt  model_1924_H.txt  model_578_H.txt
model_1024_H.txt  model_1475_H.txt  model_1925_H.txt  model_579_H.txt
model_1025_H.txt  model_1476_H.txt  model_1926_H.txt  model_57_H.txt
model_1026_H.txt  model_1477_H.txt  model_1927_H.txt  model_580_H.txt
model_1027_H.txt  model_1478_H.txt  model_1928_H.txt  model_581_H.txt
model_1028_H.txt  model_1479_H.txt  model_1929_H.txt  model_582_H.txt
model_1029_H.txt  model_147_H.txt   model_192_H.txt   model_583_H.txt
model_102_H.txt   model_1480_H.txt  model_1930_H.txt  model_584_H.txt
model_1030_H.txt  model_1481_H.txt  model_1931_H.txt  model_585_H.txt
model_1031_H.txt  model_1482_H.txt  model_1932_H.txt  model_586_H.txt
model_1032_H.txt  model_1483_H.txt  model_1933_H.txt  model_587_H.txt
model_1033_H.txt  model_1484_H.txt  model_1934_H.txt  model_588_H.txt
model_1034_H.txt  model_1485_H.txt  model_1935_H.txt  model_589_H.txt
model_1035_H.txt  model_1486_H.txt  model_1936_H.txt  model_58_H.txt
model_1036_H.txt  model_1487_H.txt  model_1937_H.txt  model_590_H.txt
model_1037_H.txt  model_1488_H.txt  model_1938_H.txt  model_591_H.txt
model_1038_H.txt  model_1489_H.txt  model_1939_H.txt  model_592_H.txt
model_1039_H.txt  model_148_H.txt   model_193_H.txt   model_593_H.txt
model_103_H.txt   model_1490_H.txt  model_1940_H.txt  model_594_H.txt
model_1040_H.txt  model_1491_H.txt  model_1941_H.txt  model_595_H.txt
model_1041_H.txt  model_1492_H.txt  model_1942_H.txt  model_596_H.txt
model_1042_H.txt  model_1493_H.txt  model_1943_H.txt  model_597_H.txt
model_1043_H.txt  model_1494_H.txt  model_1944_H.txt  model_598_H.txt
model_1044_H.txt  model_1495_H.txt  model_1945_H.txt  model_599_H.txt
model_1045_H.txt  model_1496_H.txt  model_1946_H.txt  model_59_H.txt
model_1046_H.txt  model_1497_H.txt  model_1947_H.txt  model_5_H.txt
model_1047_H.txt  model_1498_H.txt  model_1948_H.txt  model_600_H.txt
model_1048_H.txt  model_1499_H.txt  model_1949_H.txt  model_601_H.txt
model_1049_H.txt  model_149_H.txt   model_194_H.txt   model_602_H.txt
model_104_H.txt   model_14_H.txt    model_1950_H.txt  model_603_H.txt
model_1050_H.txt  model_1500_H.txt  model_1951_H.txt  model_604_H.txt
model_1051_H.txt  model_1501_H.txt  model_1952_H.txt  model_605_H.txt
model_1052_H.txt  model_1502_H.txt  model_1953_H.txt  model_606_H.txt
model_1053_H.txt  model_1503_H.txt  model_1954_H.txt  model_607_H.txt
model_1054_H.txt  model_1504_H.txt  model_1955_H.txt  model_608_H.txt
model_1055_H.txt  model_1505_H.txt  model_1956_H.txt  model_609_H.txt
model_1056_H.txt  model_1506_H.txt  model_1957_H.txt  model_60_H.txt
model_1057_H.txt  model_1507_H.txt  model_1958_H.txt  model_610_H.txt
model_1058_H.txt  model_1508_H.txt  model_1959_H.txt  model_611_H.txt
model_1059_H.txt  model_1509_H.txt  model_195_H.txt   model_612_H.txt
model_105_H.txt   model_150_H.txt   model_1960_H.txt  model_613_H.txt
model_1060_H.txt  model_1510_H.txt  model_1961_H.txt  model_614_H.txt
model_1061_H.txt  model_1511_H.txt  model_1962_H.txt  model_615_H.txt
model_1062_H.txt  model_1512_H.txt  model_1963_H.txt  model_616_H.txt
model_1063_H.txt  model_1513_H.txt  model_1964_H.txt  model_617_H.txt
model_1064_H.txt  model_1514_H.txt  model_1965_H.txt  model_618_H.txt
model_1065_H.txt  model_1515_H.txt  model_1966_H.txt  model_619_H.txt
model_1066_H.txt  model_1516_H.txt  model_1967_H.txt  model_61_H.txt
model_1067_H.txt  model_1517_H.txt  model_1968_H.txt  model_620_H.txt
model_1068_H.txt  model_1518_H.txt  model_1969_H.txt  model_621_H.txt
model_1069_H.txt  model_1519_H.txt  model_196_H.txt   model_622_H.txt
model_106_H.txt   model_151_H.txt   model_1970_H.txt  model_623_H.txt
model_1070_H.txt  model_1520_H.txt  model_1971_H.txt  model_624_H.txt
model_1071_H.txt  model_1521_H.txt  model_1972_H.txt  model_625_H.txt
model_1072_H.txt  model_1522_H.txt  model_1973_H.txt  model_626_H.txt
model_1073_H.txt  model_1523_H.txt  model_1974_H.txt  model_627_H.txt
model_1074_H.txt  model_1524_H.txt  model_1975_H.txt  model_628_H.txt
model_1075_H.txt  model_1525_H.txt  model_1976_H.txt  model_629_H.txt
model_1076_H.txt  model_1526_H.txt  model_1977_H.txt  model_62_H.txt
model_1077_H.txt  model_1527_H.txt  model_1978_H.txt  model_630_H.txt
model_1078_H.txt  model_1528_H.txt  model_1979_H.txt  model_631_H.txt
model_1079_H.txt  model_1529_H.txt  model_197_H.txt   model_632_H.txt
model_107_H.txt   model_152_H.txt   model_1980_H.txt  model_633_H.txt
model_1080_H.txt  model_1530_H.txt  model_1981_H.txt  model_634_H.txt
model_1081_H.txt  model_1531_H.txt  model_1982_H.txt  model_635_H.txt
model_1082_H.txt  model_1532_H.txt  model_1983_H.txt  model_636_H.txt
model_1083_H.txt  model_1533_H.txt  model_1984_H.txt  model_637_H.txt
model_1084_H.txt  model_1534_H.txt  model_1985_H.txt  model_638_H.txt
model_1085_H.txt  model_1535_H.txt  model_1986_H.txt  model_639_H.txt
model_1086_H.txt  model_1536_H.txt  model_1987_H.txt  model_63_H.txt
model_1087_H.txt  model_1537_H.txt  model_1988_H.txt  model_640_H.txt
model_1088_H.txt  model_1538_H.txt  model_1989_H.txt  model_641_H.txt
model_1089_H.txt  model_1539_H.txt  model_198_H.txt   model_642_H.txt
model_108_H.txt   model_153_H.txt   model_1990_H.txt  model_643_H.txt
model_1090_H.txt  model_1540_H.txt  model_1991_H.txt  model_644_H.txt
model_1091_H.txt  model_1541_H.txt  model_1992_H.txt  model_645_H.txt
model_1092_H.txt  model_1542_H.txt  model_1993_H.txt  model_646_H.txt
model_1093_H.txt  model_1543_H.txt  model_1994_H.txt  model_647_H.txt
model_1094_H.txt  model_1544_H.txt  model_1995_H.txt  model_648_H.txt
model_1095_H.txt  model_1545_H.txt  model_1996_H.txt  model_649_H.txt
model_1096_H.txt  model_1546_H.txt  model_1997_H.txt  model_64_H.txt
model_1097_H.txt  model_1547_H.txt  model_1998_H.txt  model_650_H.txt
model_1098_H.txt  model_1548_H.txt  model_1999_H.txt  model_651_H.txt
model_1099_H.txt  model_1549_H.txt  model_199_H.txt   model_652_H.txt
model_109_H.txt   model_154_H.txt   model_19_H.txt    model_653_H.txt
model_10_H.txt    model_1550_H.txt  model_200_H.txt   model_654_H.txt
model_1100_H.txt  model_1551_H.txt  model_201_H.txt   model_655_H.txt
model_1101_H.txt  model_1552_H.txt  model_202_H.txt   model_656_H.txt
model_1102_H.txt  model_1553_H.txt  model_203_H.txt   model_657_H.txt
model_1103_H.txt  model_1554_H.txt  model_204_H.txt   model_658_H.txt
model_1104_H.txt  model_1555_H.txt  model_205_H.txt   model_659_H.txt
model_1105_H.txt  model_1556_H.txt  model_206_H.txt   model_65_H.txt
model_1106_H.txt  model_1557_H.txt  model_207_H.txt   model_660_H.txt
model_1107_H.txt  model_1558_H.txt  model_208_H.txt   model_661_H.txt
model_1108_H.txt  model_1559_H.txt  model_209_H.txt   model_662_H.txt
model_1109_H.txt  model_155_H.txt   model_20_H.txt    model_663_H.txt
model_110_H.txt   model_1560_H.txt  model_210_H.txt   model_664_H.txt
model_1110_H.txt  model_1561_H.txt  model_211_H.txt   model_665_H.txt
model_1111_H.txt  model_1562_H.txt  model_212_H.txt   model_666_H.txt
model_1112_H.txt  model_1563_H.txt  model_213_H.txt   model_667_H.txt
model_1113_H.txt  model_1564_H.txt  model_214_H.txt   model_668_H.txt
model_1114_H.txt  model_1565_H.txt  model_215_H.txt   model_669_H.txt
model_1115_H.txt  model_1566_H.txt  model_216_H.txt   model_66_H.txt
model_1116_H.txt  model_1567_H.txt  model_217_H.txt   model_670_H.txt
model_1117_H.txt  model_1568_H.txt  model_218_H.txt   model_671_H.txt
model_1118_H.txt  model_1569_H.txt  model_219_H.txt   model_672_H.txt
model_1119_H.txt  model_156_H.txt   model_21_H.txt    model_673_H.txt
model_111_H.txt   model_1570_H.txt  model_220_H.txt   model_674_H.txt
model_1120_H.txt  model_1571_H.txt  model_221_H.txt   model_675_H.txt
model_1121_H.txt  model_1572_H.txt  model_222_H.txt   model_676_H.txt
model_1122_H.txt  model_1573_H.txt  model_223_H.txt   model_677_H.txt
model_1123_H.txt  model_1574_H.txt  model_224_H.txt   model_678_H.txt
model_1124_H.txt  model_1575_H.txt  model_225_H.txt   model_679_H.txt
model_1125_H.txt  model_1576_H.txt  model_226_H.txt   model_67_H.txt
model_1126_H.txt  model_1577_H.txt  model_227_H.txt   model_680_H.txt
model_1127_H.txt  model_1578_H.txt  model_228_H.txt   model_681_H.txt
model_1128_H.txt  model_1579_H.txt  model_229_H.txt   model_682_H.txt
model_1129_H.txt  model_157_H.txt   model_22_H.txt    model_683_H.txt
model_112_H.txt   model_1580_H.txt  model_230_H.txt   model_684_H.txt
model_1130_H.txt  model_1581_H.txt  model_231_H.txt   model_685_H.txt
model_1131_H.txt  model_1582_H.txt  model_232_H.txt   model_686_H.txt
model_1132_H.txt  model_1583_H.txt  model_233_H.txt   model_687_H.txt
model_1133_H.txt  model_1584_H.txt  model_234_H.txt   model_688_H.txt
model_1134_H.txt  model_1585_H.txt  model_235_H.txt   model_689_H.txt
model_1135_H.txt  model_1586_H.txt  model_236_H.txt   model_68_H.txt
model_1136_H.txt  model_1587_H.txt  model_237_H.txt   model_690_H.txt
model_1137_H.txt  model_1588_H.txt  model_238_H.txt   model_691_H.txt
model_1138_H.txt  model_1589_H.txt  model_239_H.txt   model_692_H.txt
model_1139_H.txt  model_158_H.txt   model_23_H.txt    model_693_H.txt
model_113_H.txt   model_1590_H.txt  model_240_H.txt   model_694_H.txt
model_1140_H.txt  model_1591_H.txt  model_241_H.txt   model_695_H.txt
model_1141_H.txt  model_1592_H.txt  model_242_H.txt   model_696_H.txt
model_1142_H.txt  model_1593_H.txt  model_243_H.txt   model_697_H.txt
model_1143_H.txt  model_1594_H.txt  model_244_H.txt   model_698_H.txt
model_1144_H.txt  model_1595_H.txt  model_245_H.txt   model_699_H.txt
model_1145_H.txt  model_1596_H.txt  model_246_H.txt   model_69_H.txt
model_1146_H.txt  model_1597_H.txt  model_247_H.txt   model_6_H.txt
model_1147_H.txt  model_1598_H.txt  model_248_H.txt   model_700_H.txt
model_1148_H.txt  model_1599_H.txt  model_249_H.txt   model_701_H.txt
model_1149_H.txt  model_159_H.txt   model_24_H.txt    model_702_H.txt
model_114_H.txt   model_15_H.txt    model_250_H.txt   model_703_H.txt
model_1150_H.txt  model_1600_H.txt  model_251_H.txt   model_704_H.txt
model_1151_H.txt  model_1601_H.txt  model_252_H.txt   model_705_H.txt
model_1152_H.txt  model_1602_H.txt  model_253_H.txt   model_706_H.txt
model_1153_H.txt  model_1603_H.txt  model_254_H.txt   model_707_H.txt
model_1154_H.txt  model_1604_H.txt  model_255_H.txt   model_708_H.txt
model_1155_H.txt  model_1605_H.txt  model_256_H.txt   model_709_H.txt
model_1156_H.txt  model_1606_H.txt  model_257_H.txt   model_70_H.txt
model_1157_H.txt  model_1607_H.txt  model_258_H.txt   model_710_H.txt
model_1158_H.txt  model_1608_H.txt  model_259_H.txt   model_711_H.txt
model_1159_H.txt  model_1609_H.txt  model_25_H.txt    model_712_H.txt
model_115_H.txt   model_160_H.txt   model_260_H.txt   model_713_H.txt
model_1160_H.txt  model_1610_H.txt  model_261_H.txt   model_714_H.txt
model_1161_H.txt  model_1611_H.txt  model_262_H.txt   model_715_H.txt
model_1162_H.txt  model_1612_H.txt  model_263_H.txt   model_716_H.txt
model_1163_H.txt  model_1613_H.txt  model_264_H.txt   model_717_H.txt
model_1164_H.txt  model_1614_H.txt  model_265_H.txt   model_718_H.txt
model_1165_H.txt  model_1615_H.txt  model_266_H.txt   model_719_H.txt
model_1166_H.txt  model_1616_H.txt  model_267_H.txt   model_71_H.txt
model_1167_H.txt  model_1617_H.txt  model_268_H.txt   model_720_H.txt
model_1168_H.txt  model_1618_H.txt  model_269_H.txt   model_721_H.txt
model_1169_H.txt  model_1619_H.txt  model_26_H.txt    model_722_H.txt
model_116_H.txt   model_161_H.txt   model_270_H.txt   model_723_H.txt
model_1170_H.txt  model_1620_H.txt  model_271_H.txt   model_724_H.txt
model_1171_H.txt  model_1621_H.txt  model_272_H.txt   model_725_H.txt
model_1172_H.txt  model_1622_H.txt  model_273_H.txt   model_726_H.txt
model_1173_H.txt  model_1623_H.txt  model_274_H.txt   model_727_H.txt
model_1174_H.txt  model_1624_H.txt  model_275_H.txt   model_728_H.txt
model_1175_H.txt  model_1625_H.txt  model_276_H.txt   model_729_H.txt
model_1176_H.txt  model_1626_H.txt  model_277_H.txt   model_72_H.txt
model_1177_H.txt  model_1627_H.txt  model_278_H.txt   model_730_H.txt
model_1178_H.txt  model_1628_H.txt  model_279_H.txt   model_731_H.txt
model_1179_H.txt  model_1629_H.txt  model_27_H.txt    model_732_H.txt
model_117_H.txt   model_162_H.txt   model_280_H.txt   model_733_H.txt
model_1180_H.txt  model_1630_H.txt  model_281_H.txt   model_734_H.txt
model_1181_H.txt  model_1631_H.txt  model_282_H.txt   model_735_H.txt
model_1182_H.txt  model_1632_H.txt  model_283_H.txt   model_736_H.txt
model_1183_H.txt  model_1633_H.txt  model_284_H.txt   model_737_H.txt
model_1184_H.txt  model_1634_H.txt  model_285_H.txt   model_738_H.txt
model_1185_H.txt  model_1635_H.txt  model_286_H.txt   model_739_H.txt
model_1186_H.txt  model_1636_H.txt  model_287_H.txt   model_73_H.txt
model_1187_H.txt  model_1637_H.txt  model_288_H.txt   model_740_H.txt
model_1188_H.txt  model_1638_H.txt  model_289_H.txt   model_741_H.txt
model_1189_H.txt  model_1639_H.txt  model_28_H.txt    model_742_H.txt
model_118_H.txt   model_163_H.txt   model_290_H.txt   model_743_H.txt
model_1190_H.txt  model_1640_H.txt  model_291_H.txt   model_744_H.txt
model_1191_H.txt  model_1641_H.txt  model_292_H.txt   model_745_H.txt
model_1192_H.txt  model_1642_H.txt  model_293_H.txt   model_746_H.txt
model_1193_H.txt  model_1643_H.txt  model_294_H.txt   model_747_H.txt
model_1194_H.txt  model_1644_H.txt  model_295_H.txt   model_748_H.txt
model_1195_H.txt  model_1645_H.txt  model_296_H.txt   model_749_H.txt
model_1196_H.txt  model_1646_H.txt  model_297_H.txt   model_74_H.txt
model_1197_H.txt  model_1647_H.txt  model_298_H.txt   model_750_H.txt
model_1198_H.txt  model_1648_H.txt  model_299_H.txt   model_751_H.txt
model_1199_H.txt  model_1649_H.txt  model_29_H.txt    model_752_H.txt
model_119_H.txt   model_164_H.txt   model_300_H.txt   model_753_H.txt
model_11_H.txt    model_1650_H.txt  model_301_H.txt   model_754_H.txt
model_1200_H.txt  model_1651_H.txt  model_302_H.txt   model_755_H.txt
model_1201_H.txt  model_1652_H.txt  model_303_H.txt   model_756_H.txt
model_1202_H.txt  model_1653_H.txt  model_304_H.txt   model_757_H.txt
model_1203_H.txt  model_1654_H.txt  model_305_H.txt   model_758_H.txt
model_1204_H.txt  model_1655_H.txt  model_306_H.txt   model_759_H.txt
model_1205_H.txt  model_1656_H.txt  model_307_H.txt   model_75_H.txt
model_1206_H.txt  model_1657_H.txt  model_308_H.txt   model_760_H.txt
model_1207_H.txt  model_1658_H.txt  model_309_H.txt   model_761_H.txt
model_1208_H.txt  model_1659_H.txt  model_30_H.txt    model_762_H.txt
model_1209_H.txt  model_165_H.txt   model_310_H.txt   model_763_H.txt
model_120_H.txt   model_1660_H.txt  model_311_H.txt   model_764_H.txt
model_1210_H.txt  model_1661_H.txt  model_312_H.txt   model_765_H.txt
model_1211_H.txt  model_1662_H.txt  model_313_H.txt   model_766_H.txt
model_1212_H.txt  model_1663_H.txt  model_314_H.txt   model_767_H.txt
model_1213_H.txt  model_1664_H.txt  model_315_H.txt   model_768_H.txt
model_1214_H.txt  model_1665_H.txt  model_316_H.txt   model_769_H.txt
model_1215_H.txt  model_1666_H.txt  model_317_H.txt   model_76_H.txt
model_1216_H.txt  model_1667_H.txt  model_318_H.txt   model_770_H.txt
model_1217_H.txt  model_1668_H.txt  model_319_H.txt   model_771_H.txt
model_1218_H.txt  model_1669_H.txt  model_31_H.txt    model_772_H.txt
model_1219_H.txt  model_166_H.txt   model_320_H.txt   model_773_H.txt
model_121_H.txt   model_1670_H.txt  model_321_H.txt   model_774_H.txt
model_1220_H.txt  model_1671_H.txt  model_322_H.txt   model_775_H.txt
model_1221_H.txt  model_1672_H.txt  model_323_H.txt   model_776_H.txt
model_1222_H.txt  model_1673_H.txt  model_324_H.txt   model_777_H.txt
model_1223_H.txt  model_1674_H.txt  model_325_H.txt   model_778_H.txt
model_1224_H.txt  model_1675_H.txt  model_326_H.txt   model_779_H.txt
model_1225_H.txt  model_1676_H.txt  model_327_H.txt   model_77_H.txt
model_1226_H.txt  model_1677_H.txt  model_328_H.txt   model_780_H.txt
model_1227_H.txt  model_1678_H.txt  model_329_H.txt   model_781_H.txt
model_1228_H.txt  model_1679_H.txt  model_32_H.txt    model_782_H.txt
model_1229_H.txt  model_167_H.txt   model_330_H.txt   model_783_H.txt
model_122_H.txt   model_1680_H.txt  model_331_H.txt   model_784_H.txt
model_1230_H.txt  model_1681_H.txt  model_332_H.txt   model_785_H.txt
model_1231_H.txt  model_1682_H.txt  model_333_H.txt   model_786_H.txt
model_1232_H.txt  model_1683_H.txt  model_334_H.txt   model_787_H.txt
model_1233_H.txt  model_1684_H.txt  model_335_H.txt   model_788_H.txt
model_1234_H.txt  model_1685_H.txt  model_336_H.txt   model_789_H.txt
model_1235_H.txt  model_1686_H.txt  model_337_H.txt   model_78_H.txt
model_1236_H.txt  model_1687_H.txt  model_338_H.txt   model_790_H.txt
model_1237_H.txt  model_1688_H.txt  model_339_H.txt   model_791_H.txt
model_1238_H.txt  model_1689_H.txt  model_33_H.txt    model_792_H.txt
model_1239_H.txt  model_168_H.txt   model_340_H.txt   model_793_H.txt
model_123_H.txt   model_1690_H.txt  model_341_H.txt   model_794_H.txt
model_1240_H.txt  model_1691_H.txt  model_342_H.txt   model_795_H.txt
model_1241_H.txt  model_1692_H.txt  model_343_H.txt   model_796_H.txt
model_1242_H.txt  model_1693_H.txt  model_344_H.txt   model_797_H.txt
model_1243_H.txt  model_1694_H.txt  model_345_H.txt   model_798_H.txt
model_1244_H.txt  model_1695_H.txt  model_346_H.txt   model_799_H.txt
model_1245_H.txt  model_1696_H.txt  model_347_H.txt   model_79_H.txt
model_1246_H.txt  model_1697_H.txt  model_348_H.txt   model_7_H.txt
model_1247_H.txt  model_1698_H.txt  model_349_H.txt   model_800_H.txt
model_1248_H.txt  model_1699_H.txt  model_34_H.txt    model_801_H.txt
model_1249_H.txt  model_169_H.txt   model_350_H.txt   model_802_H.txt
model_124_H.txt   model_16_H.txt    model_351_H.txt   model_803_H.txt
model_1250_H.txt  model_1700_H.txt  model_352_H.txt   model_804_H.txt
model_1251_H.txt  model_1701_H.txt  model_353_H.txt   model_805_H.txt
model_1252_H.txt  model_1702_H.txt  model_354_H.txt   model_806_H.txt
model_1253_H.txt  model_1703_H.txt  model_355_H.txt   model_807_H.txt
model_1254_H.txt  model_1704_H.txt  model_356_H.txt   model_808_H.txt
model_1255_H.txt  model_1705_H.txt  model_357_H.txt   model_809_H.txt
model_1256_H.txt  model_1706_H.txt  model_358_H.txt   model_80_H.txt
model_1257_H.txt  model_1707_H.txt  model_359_H.txt   model_810_H.txt
model_1258_H.txt  model_1708_H.txt  model_35_H.txt    model_811_H.txt
model_1259_H.txt  model_1709_H.txt  model_360_H.txt   model_812_H.txt
model_125_H.txt   model_170_H.txt   model_361_H.txt   model_813_H.txt
model_1260_H.txt  model_1710_H.txt  model_362_H.txt   model_814_H.txt
model_1261_H.txt  model_1711_H.txt  model_363_H.txt   model_815_H.txt
model_1262_H.txt  model_1712_H.txt  model_364_H.txt   model_816_H.txt
model_1263_H.txt  model_1713_H.txt  model_365_H.txt   model_817_H.txt
model_1264_H.txt  model_1714_H.txt  model_366_H.txt   model_818_H.txt
model_1265_H.txt  model_1715_H.txt  model_367_H.txt   model_819_H.txt
model_1266_H.txt  model_1716_H.txt  model_368_H.txt   model_81_H.txt
model_1267_H.txt  model_1717_H.txt  model_369_H.txt   model_820_H.txt
model_1268_H.txt  model_1718_H.txt  model_36_H.txt    model_821_H.txt
model_1269_H.txt  model_1719_H.txt  model_370_H.txt   model_822_H.txt
model_126_H.txt   model_171_H.txt   model_371_H.txt   model_823_H.txt
model_1270_H.txt  model_1720_H.txt  model_372_H.txt   model_824_H.txt
model_1271_H.txt  model_1721_H.txt  model_373_H.txt   model_825_H.txt
model_1272_H.txt  model_1722_H.txt  model_374_H.txt   model_826_H.txt
model_1273_H.txt  model_1723_H.txt  model_375_H.txt   model_827_H.txt
model_1274_H.txt  model_1724_H.txt  model_376_H.txt   model_828_H.txt
model_1275_H.txt  model_1725_H.txt  model_377_H.txt   model_829_H.txt
model_1276_H.txt  model_1726_H.txt  model_378_H.txt   model_82_H.txt
model_1277_H.txt  model_1727_H.txt  model_379_H.txt   model_830_H.txt
model_1278_H.txt  model_1728_H.txt  model_37_H.txt    model_831_H.txt
model_1279_H.txt  model_1729_H.txt  model_380_H.txt   model_832_H.txt
model_127_H.txt   model_172_H.txt   model_381_H.txt   model_833_H.txt
model_1280_H.txt  model_1730_H.txt  model_382_H.txt   model_834_H.txt
model_1281_H.txt  model_1731_H.txt  model_383_H.txt   model_835_H.txt
model_1282_H.txt  model_1732_H.txt  model_384_H.txt   model_836_H.txt
model_1283_H.txt  model_1733_H.txt  model_385_H.txt   model_837_H.txt
model_1284_H.txt  model_1734_H.txt  model_386_H.txt   model_838_H.txt
model_1285_H.txt  model_1735_H.txt  model_387_H.txt   model_839_H.txt
model_1286_H.txt  model_1736_H.txt  model_388_H.txt   model_83_H.txt
model_1287_H.txt  model_1737_H.txt  model_389_H.txt   model_840_H.txt
model_1288_H.txt  model_1738_H.txt  model_38_H.txt    model_841_H.txt
model_1289_H.txt  model_1739_H.txt  model_390_H.txt   model_842_H.txt
model_128_H.txt   model_173_H.txt   model_391_H.txt   model_843_H.txt
model_1290_H.txt  model_1740_H.txt  model_392_H.txt   model_844_H.txt
model_1291_H.txt  model_1741_H.txt  model_393_H.txt   model_845_H.txt
model_1292_H.txt  model_1742_H.txt  model_394_H.txt   model_846_H.txt
model_1293_H.txt  model_1743_H.txt  model_395_H.txt   model_847_H.txt
model_1294_H.txt  model_1744_H.txt  model_396_H.txt   model_848_H.txt
model_1295_H.txt  model_1745_H.txt  model_397_H.txt   model_849_H.txt
model_1296_H.txt  model_1746_H.txt  model_398_H.txt   model_84_H.txt
model_1297_H.txt  model_1747_H.txt  model_399_H.txt   model_850_H.txt
model_1298_H.txt  model_1748_H.txt  model_39_H.txt    model_851_H.txt
model_1299_H.txt  model_1749_H.txt  model_400_H.txt   model_852_H.txt
model_129_H.txt   model_174_H.txt   model_401_H.txt   model_853_H.txt
model_12_H.txt    model_1750_H.txt  model_402_H.txt   model_854_H.txt
model_1300_H.txt  model_1751_H.txt  model_403_H.txt   model_855_H.txt
model_1301_H.txt  model_1752_H.txt  model_404_H.txt   model_856_H.txt
model_1302_H.txt  model_1753_H.txt  model_405_H.txt   model_857_H.txt
model_1303_H.txt  model_1754_H.txt  model_406_H.txt   model_858_H.txt
model_1304_H.txt  model_1755_H.txt  model_407_H.txt   model_859_H.txt
model_1305_H.txt  model_1756_H.txt  model_408_H.txt   model_85_H.txt
model_1306_H.txt  model_1757_H.txt  model_409_H.txt   model_860_H.txt
model_1307_H.txt  model_1758_H.txt  model_40_H.txt    model_861_H.txt
model_1308_H.txt  model_1759_H.txt  model_410_H.txt   model_862_H.txt
model_1309_H.txt  model_175_H.txt   model_411_H.txt   model_863_H.txt
model_130_H.txt   model_1760_H.txt  model_412_H.txt   model_864_H.txt
model_1310_H.txt  model_1761_H.txt  model_413_H.txt   model_865_H.txt
model_1311_H.txt  model_1762_H.txt  model_414_H.txt   model_866_H.txt
model_1312_H.txt  model_1763_H.txt  model_415_H.txt   model_867_H.txt
model_1313_H.txt  model_1764_H.txt  model_416_H.txt   model_868_H.txt
model_1314_H.txt  model_1765_H.txt  model_417_H.txt   model_869_H.txt
model_1315_H.txt  model_1766_H.txt  model_418_H.txt   model_86_H.txt
model_1316_H.txt  model_1767_H.txt  model_419_H.txt   model_870_H.txt
model_1317_H.txt  model_1768_H.txt  model_41_H.txt    model_871_H.txt
model_1318_H.txt  model_1769_H.txt  model_420_H.txt   model_872_H.txt
model_1319_H.txt  model_176_H.txt   model_421_H.txt   model_873_H.txt
model_131_H.txt   model_1770_H.txt  model_422_H.txt   model_874_H.txt
model_1320_H.txt  model_1771_H.txt  model_423_H.txt   model_875_H.txt
model_1321_H.txt  model_1772_H.txt  model_424_H.txt   model_876_H.txt
model_1322_H.txt  model_1773_H.txt  model_425_H.txt   model_877_H.txt
model_1323_H.txt  model_1774_H.txt  model_426_H.txt   model_878_H.txt
model_1324_H.txt  model_1775_H.txt  model_427_H.txt   model_879_H.txt
model_1325_H.txt  model_1776_H.txt  model_428_H.txt   model_87_H.txt
model_1326_H.txt  model_1777_H.txt  model_429_H.txt   model_880_H.txt
model_1327_H.txt  model_1778_H.txt  model_42_H.txt    model_881_H.txt
model_1328_H.txt  model_1779_H.txt  model_430_H.txt   model_882_H.txt
model_1329_H.txt  model_177_H.txt   model_431_H.txt   model_883_H.txt
model_132_H.txt   model_1780_H.txt  model_432_H.txt   model_884_H.txt
model_1330_H.txt  model_1781_H.txt  model_433_H.txt   model_885_H.txt
model_1331_H.txt  model_1782_H.txt  model_434_H.txt   model_886_H.txt
model_1332_H.txt  model_1783_H.txt  model_435_H.txt   model_887_H.txt
model_1333_H.txt  model_1784_H.txt  model_436_H.txt   model_888_H.txt
model_1334_H.txt  model_1785_H.txt  model_437_H.txt   model_889_H.txt
model_1335_H.txt  model_1786_H.txt  model_438_H.txt   model_88_H.txt
model_1336_H.txt  model_1787_H.txt  model_439_H.txt   model_890_H.txt
model_1337_H.txt  model_1788_H.txt  model_43_H.txt    model_891_H.txt
model_1338_H.txt  model_1789_H.txt  model_440_H.txt   model_892_H.txt
model_1339_H.txt  model_178_H.txt   model_441_H.txt   model_893_H.txt
model_133_H.txt   model_1790_H.txt  model_442_H.txt   model_894_H.txt
model_1340_H.txt  model_1791_H.txt  model_443_H.txt   model_895_H.txt
model_1341_H.txt  model_1792_H.txt  model_444_H.txt   model_896_H.txt
model_1342_H.txt  model_1793_H.txt  model_445_H.txt   model_897_H.txt
model_1343_H.txt  model_1794_H.txt  model_446_H.txt   model_898_H.txt
model_1344_H.txt  model_1795_H.txt  model_447_H.txt   model_899_H.txt
model_1345_H.txt  model_1796_H.txt  model_448_H.txt   model_89_H.txt
model_1346_H.txt  model_1797_H.txt  model_449_H.txt   model_8_H.txt
model_1347_H.txt  model_1798_H.txt  model_44_H.txt    model_900_H.txt
model_1348_H.txt  model_1799_H.txt  model_450_H.txt   model_901_H.txt
model_1349_H.txt  model_179_H.txt   model_451_H.txt   model_902_H.txt
model_134_H.txt   model_17_H.txt    model_452_H.txt   model_903_H.txt
model_1350_H.txt  model_1800_H.txt  model_453_H.txt   model_904_H.txt
model_1351_H.txt  model_1801_H.txt  model_454_H.txt   model_905_H.txt
model_1352_H.txt  model_1802_H.txt  model_455_H.txt   model_906_H.txt
model_1353_H.txt  model_1803_H.txt  model_456_H.txt   model_907_H.txt
model_1354_H.txt  model_1804_H.txt  model_457_H.txt   model_908_H.txt
model_1355_H.txt  model_1805_H.txt  model_458_H.txt   model_909_H.txt
model_1356_H.txt  model_1806_H.txt  model_459_H.txt   model_90_H.txt
model_1357_H.txt  model_1807_H.txt  model_45_H.txt    model_910_H.txt
model_1358_H.txt  model_1808_H.txt  model_460_H.txt   model_911_H.txt
model_1359_H.txt  model_1809_H.txt  model_461_H.txt   model_912_H.txt
model_135_H.txt   model_180_H.txt   model_462_H.txt   model_913_H.txt
model_1360_H.txt  model_1810_H.txt  model_463_H.txt   model_914_H.txt
model_1361_H.txt  model_1811_H.txt  model_464_H.txt   model_915_H.txt
model_1362_H.txt  model_1812_H.txt  model_465_H.txt   model_916_H.txt
model_1363_H.txt  model_1813_H.txt  model_466_H.txt   model_917_H.txt
model_1364_H.txt  model_1814_H.txt  model_467_H.txt   model_918_H.txt
model_1365_H.txt  model_1815_H.txt  model_468_H.txt   model_919_H.txt
model_1366_H.txt  model_1816_H.txt  model_469_H.txt   model_91_H.txt
model_1367_H.txt  model_1817_H.txt  model_46_H.txt    model_920_H.txt
model_1368_H.txt  model_1818_H.txt  model_470_H.txt   model_921_H.txt
model_1369_H.txt  model_1819_H.txt  model_471_H.txt   model_922_H.txt
model_136_H.txt   model_181_H.txt   model_472_H.txt   model_923_H.txt
model_1370_H.txt  model_1820_H.txt  model_473_H.txt   model_924_H.txt
model_1371_H.txt  model_1821_H.txt  model_474_H.txt   model_925_H.txt
model_1372_H.txt  model_1822_H.txt  model_475_H.txt   model_926_H.txt
model_1373_H.txt  model_1823_H.txt  model_476_H.txt   model_927_H.txt
model_1374_H.txt  model_1824_H.txt  model_477_H.txt   model_928_H.txt
model_1375_H.txt  model_1825_H.txt  model_478_H.txt   model_929_H.txt
model_1376_H.txt  model_1826_H.txt  model_479_H.txt   model_92_H.txt
model_1377_H.txt  model_1827_H.txt  model_47_H.txt    model_930_H.txt
model_1378_H.txt  model_1828_H.txt  model_480_H.txt   model_931_H.txt
model_1379_H.txt  model_1829_H.txt  model_481_H.txt   model_932_H.txt
model_137_H.txt   model_182_H.txt   model_482_H.txt   model_933_H.txt
model_1380_H.txt  model_1830_H.txt  model_483_H.txt   model_934_H.txt
model_1381_H.txt  model_1831_H.txt  model_484_H.txt   model_935_H.txt
model_1382_H.txt  model_1832_H.txt  model_485_H.txt   model_936_H.txt
model_1383_H.txt  model_1833_H.txt  model_486_H.txt   model_937_H.txt
model_1384_H.txt  model_1834_H.txt  model_487_H.txt   model_938_H.txt
model_1385_H.txt  model_1835_H.txt  model_488_H.txt   model_939_H.txt
model_1386_H.txt  model_1836_H.txt  model_489_H.txt   model_93_H.txt
model_1387_H.txt  model_1837_H.txt  model_48_H.txt    model_940_H.txt
model_1388_H.txt  model_1838_H.txt  model_490_H.txt   model_941_H.txt
model_1389_H.txt  model_1839_H.txt  model_491_H.txt   model_942_H.txt
model_138_H.txt   model_183_H.txt   model_492_H.txt   model_943_H.txt
model_1390_H.txt  model_1840_H.txt  model_493_H.txt   model_944_H.txt
model_1391_H.txt  model_1841_H.txt  model_494_H.txt   model_945_H.txt
model_1392_H.txt  model_1842_H.txt  model_495_H.txt   model_946_H.txt
model_1393_H.txt  model_1843_H.txt  model_496_H.txt   model_947_H.txt
model_1394_H.txt  model_1844_H.txt  model_497_H.txt   model_948_H.txt
model_1395_H.txt  model_1845_H.txt  model_498_H.txt   model_949_H.txt
model_1396_H.txt  model_1846_H.txt  model_499_H.txt   model_94_H.txt
model_1397_H.txt  model_1847_H.txt  model_49_H.txt    model_950_H.txt
model_1398_H.txt  model_1848_H.txt  model_500_H.txt   model_951_H.txt
model_1399_H.txt  model_1849_H.txt  model_501_H.txt   model_952_H.txt
model_139_H.txt   model_184_H.txt   model_502_H.txt   model_953_H.txt
model_13_H.txt    model_1850_H.txt  model_503_H.txt   model_954_H.txt
model_1400_H.txt  model_1851_H.txt  model_504_H.txt   model_955_H.txt
model_1401_H.txt  model_1852_H.txt  model_505_H.txt   model_956_H.txt
model_1402_H.txt  model_1853_H.txt  model_506_H.txt   model_957_H.txt
model_1403_H.txt  model_1854_H.txt  model_507_H.txt   model_958_H.txt
model_1404_H.txt  model_1855_H.txt  model_508_H.txt   model_959_H.txt
model_1405_H.txt  model_1856_H.txt  model_509_H.txt   model_95_H.txt
model_1406_H.txt  model_1857_H.txt  model_50_H.txt    model_960_H.txt
model_1407_H.txt  model_1858_H.txt  model_510_H.txt   model_961_H.txt
model_1408_H.txt  model_1859_H.txt  model_511_H.txt   model_962_H.txt
model_1409_H.txt  model_185_H.txt   model_512_H.txt   model_963_H.txt
model_140_H.txt   model_1860_H.txt  model_513_H.txt   model_964_H.txt
model_1410_H.txt  model_1861_H.txt  model_514_H.txt   model_965_H.txt
model_1411_H.txt  model_1862_H.txt  model_515_H.txt   model_966_H.txt
model_1412_H.txt  model_1863_H.txt  model_516_H.txt   model_967_H.txt
model_1413_H.txt  model_1864_H.txt  model_517_H.txt   model_968_H.txt
model_1414_H.txt  model_1865_H.txt  model_518_H.txt   model_969_H.txt
model_1415_H.txt  model_1866_H.txt  model_519_H.txt   model_96_H.txt
model_1416_H.txt  model_1867_H.txt  model_51_H.txt    model_970_H.txt
model_1417_H.txt  model_1868_H.txt  model_520_H.txt   model_971_H.txt
model_1418_H.txt  model_1869_H.txt  model_521_H.txt   model_972_H.txt
model_1419_H.txt  model_186_H.txt   model_522_H.txt   model_973_H.txt
model_141_H.txt   model_1870_H.txt  model_523_H.txt   model_974_H.txt
model_1420_H.txt  model_1871_H.txt  model_524_H.txt   model_975_H.txt
model_1421_H.txt  model_1872_H.txt  model_525_H.txt   model_976_H.txt
model_1422_H.txt  model_1873_H.txt  model_526_H.txt   model_977_H.txt
model_1423_H.txt  model_1874_H.txt  model_527_H.txt   model_978_H.txt
model_1424_H.txt  model_1875_H.txt  model_528_H.txt   model_979_H.txt
model_1425_H.txt  model_1876_H.txt  model_529_H.txt   model_97_H.txt
model_1426_H.txt  model_1877_H.txt  model_52_H.txt    model_980_H.txt
model_1427_H.txt  model_1878_H.txt  model_530_H.txt   model_981_H.txt
model_1428_H.txt  model_1879_H.txt  model_531_H.txt   model_982_H.txt
model_1429_H.txt  model_187_H.txt   model_532_H.txt   model_983_H.txt
model_142_H.txt   model_1880_H.txt  model_533_H.txt   model_984_H.txt
model_1430_H.txt  model_1881_H.txt  model_534_H.txt   model_985_H.txt
model_1431_H.txt  model_1882_H.txt  model_535_H.txt   model_986_H.txt
model_1432_H.txt  model_1883_H.txt  model_536_H.txt   model_987_H.txt
model_1433_H.txt  model_1884_H.txt  model_537_H.txt   model_988_H.txt
model_1434_H.txt  model_1885_H.txt  model_538_H.txt   model_989_H.txt
model_1435_H.txt  model_1886_H.txt  model_539_H.txt   model_98_H.txt
model_1436_H.txt  model_1887_H.txt  model_53_H.txt    model_990_H.txt
model_1437_H.txt  model_1888_H.txt  model_540_H.txt   model_991_H.txt
model_1438_H.txt  model_1889_H.txt  model_541_H.txt   model_992_H.txt
model_1439_H.txt  model_188_H.txt   model_542_H.txt   model_993_H.txt
model_143_H.txt   model_1890_H.txt  model_543_H.txt   model_994_H.txt
model_1440_H.txt  model_1891_H.txt  model_544_H.txt   model_995_H.txt
model_1441_H.txt  model_1892_H.txt  model_545_H.txt   model_996_H.txt
model_1442_H.txt  model_1893_H.txt  model_546_H.txt   model_997_H.txt
model_1443_H.txt  model_1894_H.txt  model_547_H.txt   model_998_H.txt
model_1444_H.txt  model_1895_H.txt  model_548_H.txt   model_999_H.txt
model_1445_H.txt  model_1896_H.txt  model_549_H.txt   model_99_H.txt
model_1446_H.txt  model_1897_H.txt  model_54_H.txt    model_9_H.txt
model_1447_H.txt  model_1898_H.txt  model_550_H.txt   radar_FM1D_refMethod.py*
model_1448_H.txt  model_1899_H.txt  model_551_H.txt   runModels.sh
model_1449_H.txt  model_189_H.txt   model_552_H.txt
model_144_H.txt   model_18_H.txt    model_553_H.txt
model_1450_H.txt  model_1900_H.txt  model_554_H.txt

#Now running the shellscript to run each model.
!sh runModels.sh

Note: the script was running slowly so I stopped it early, but still got several thousand model datasets.

ls *.csv

model_1000_H_model.csv        model_1393_H_model.csv
model_1000_H_output_data.csv  model_1393_H_output_data.csv
model_1001_H_model.csv        model_1394_H_model.csv
model_1001_H_output_data.csv  model_1394_H_output_data.csv
model_1002_H_model.csv        model_1395_H_model.csv
model_1002_H_output_data.csv  model_1395_H_output_data.csv
model_1003_H_model.csv        model_1396_H_model.csv
model_1003_H_output_data.csv  model_1396_H_output_data.csv
model_1004_H_model.csv        model_1397_H_model.csv
model_1004_H_output_data.csv  model_1397_H_output_data.csv
model_1005_H_model.csv        model_1398_H_model.csv
model_1005_H_output_data.csv  model_1398_H_output_data.csv
model_1006_H_model.csv        model_1399_H_model.csv
model_1006_H_output_data.csv  model_1399_H_output_data.csv
model_1007_H_model.csv        model_139_H_model.csv
model_1007_H_output_data.csv  model_139_H_output_data.csv
model_1008_H_model.csv        model_13_H_model.csv
model_1008_H_output_data.csv  model_13_H_output_data.csv
model_1009_H_model.csv        model_1400_H_model.csv
model_1009_H_output_data.csv  model_1400_H_output_data.csv
model_100_H_model.csv         model_1401_H_model.csv
model_100_H_output_data.csv   model_1401_H_output_data.csv
model_1010_H_model.csv        model_1402_H_model.csv
model_1010_H_output_data.csv  model_1402_H_output_data.csv
model_1011_H_model.csv        model_1403_H_model.csv
model_1011_H_output_data.csv  model_1403_H_output_data.csv
model_1012_H_model.csv        model_1404_H_model.csv
model_1012_H_output_data.csv  model_1404_H_output_data.csv
model_1013_H_model.csv        model_1405_H_model.csv
model_1013_H_output_data.csv  model_1405_H_output_data.csv
model_1014_H_model.csv        model_1406_H_model.csv
model_1014_H_output_data.csv  model_1406_H_output_data.csv
model_1015_H_model.csv        model_1407_H_model.csv
model_1015_H_output_data.csv  model_1407_H_output_data.csv
model_1016_H_model.csv        model_1408_H_model.csv
model_1016_H_output_data.csv  model_1408_H_output_data.csv
model_1017_H_model.csv        model_1409_H_model.csv
model_1017_H_output_data.csv  model_1409_H_output_data.csv
model_1018_H_model.csv        model_140_H_model.csv
model_1018_H_output_data.csv  model_140_H_output_data.csv
model_1019_H_model.csv        model_1410_H_model.csv
model_1019_H_output_data.csv  model_1410_H_output_data.csv
model_101_H_model.csv         model_1411_H_model.csv
model_101_H_output_data.csv   model_1411_H_output_data.csv
model_1020_H_model.csv        model_1412_H_model.csv
model_1020_H_output_data.csv  model_1412_H_output_data.csv
model_1021_H_model.csv        model_1413_H_model.csv
model_1021_H_output_data.csv  model_1413_H_output_data.csv
model_1022_H_model.csv        model_1414_H_model.csv
model_1022_H_output_data.csv  model_1414_H_output_data.csv
model_1023_H_model.csv        model_1415_H_model.csv
model_1023_H_output_data.csv  model_1415_H_output_data.csv
model_1024_H_model.csv        model_1416_H_model.csv
model_1024_H_output_data.csv  model_1416_H_output_data.csv
model_1025_H_model.csv        model_1417_H_model.csv
model_1025_H_output_data.csv  model_1417_H_output_data.csv
model_1026_H_model.csv        model_1418_H_model.csv
model_1026_H_output_data.csv  model_1418_H_output_data.csv
model_1027_H_model.csv        model_1419_H_model.csv
model_1027_H_output_data.csv  model_1419_H_output_data.csv
model_1028_H_model.csv        model_141_H_model.csv
model_1028_H_output_data.csv  model_141_H_output_data.csv
model_1029_H_model.csv        model_1420_H_model.csv
model_1029_H_output_data.csv  model_1420_H_output_data.csv
model_102_H_model.csv         model_1421_H_model.csv
model_102_H_output_data.csv   model_1421_H_output_data.csv
model_1030_H_model.csv        model_1422_H_model.csv
model_1030_H_output_data.csv  model_1422_H_output_data.csv
model_1031_H_model.csv        model_1423_H_model.csv
model_1031_H_output_data.csv  model_1423_H_output_data.csv
model_1032_H_model.csv        model_1424_H_model.csv
model_1032_H_output_data.csv  model_1424_H_output_data.csv
model_1033_H_model.csv        model_1425_H_model.csv
model_1033_H_output_data.csv  model_1425_H_output_data.csv
model_1034_H_model.csv        model_1426_H_model.csv
model_1034_H_output_data.csv  model_1426_H_output_data.csv
model_1035_H_model.csv        model_1427_H_model.csv
model_1035_H_output_data.csv  model_1427_H_output_data.csv
model_1036_H_model.csv        model_1428_H_model.csv
model_1036_H_output_data.csv  model_1428_H_output_data.csv
model_1037_H_model.csv        model_1429_H_model.csv
model_1037_H_output_data.csv  model_1429_H_output_data.csv
model_1038_H_model.csv        model_142_H_model.csv
model_1038_H_output_data.csv  model_142_H_output_data.csv
model_1039_H_model.csv        model_1430_H_model.csv
model_1039_H_output_data.csv  model_1430_H_output_data.csv
model_103_H_model.csv         model_1431_H_model.csv
model_103_H_output_data.csv   model_1431_H_output_data.csv
model_1040_H_model.csv        model_1432_H_model.csv
model_1040_H_output_data.csv  model_1432_H_output_data.csv
model_1041_H_model.csv        model_1433_H_model.csv
model_1041_H_output_data.csv  model_1433_H_output_data.csv
model_1042_H_model.csv        model_1434_H_model.csv
model_1042_H_output_data.csv  model_1434_H_output_data.csv
model_1043_H_model.csv        model_1435_H_model.csv
model_1043_H_output_data.csv  model_1435_H_output_data.csv
model_1044_H_model.csv        model_1436_H_model.csv
model_1044_H_output_data.csv  model_1436_H_output_data.csv
model_1045_H_model.csv        model_1437_H_model.csv
model_1045_H_output_data.csv  model_1437_H_output_data.csv
model_1046_H_model.csv        model_1438_H_model.csv
model_1046_H_output_data.csv  model_1438_H_output_data.csv
model_1047_H_model.csv        model_1439_H_model.csv
model_1047_H_output_data.csv  model_1439_H_output_data.csv
model_1048_H_model.csv        model_143_H_model.csv
model_1048_H_output_data.csv  model_143_H_output_data.csv
model_1049_H_model.csv        model_1440_H_model.csv
model_1049_H_output_data.csv  model_1440_H_output_data.csv
model_104_H_model.csv         model_1441_H_model.csv
model_104_H_output_data.csv   model_1441_H_output_data.csv
model_1050_H_model.csv        model_1442_H_model.csv
model_1050_H_output_data.csv  model_1442_H_output_data.csv
model_1051_H_model.csv        model_1443_H_model.csv
model_1051_H_output_data.csv  model_1443_H_output_data.csv
model_1052_H_model.csv        model_1444_H_model.csv
model_1052_H_output_data.csv  model_1444_H_output_data.csv
model_1053_H_model.csv        model_1445_H_model.csv
model_1053_H_output_data.csv  model_1445_H_output_data.csv
model_1054_H_model.csv        model_1446_H_model.csv
model_1054_H_output_data.csv  model_1446_H_output_data.csv
model_1055_H_model.csv        model_1447_H_model.csv
model_1055_H_output_data.csv  model_1447_H_output_data.csv
model_1056_H_model.csv        model_1448_H_model.csv
model_1056_H_output_data.csv  model_1448_H_output_data.csv
model_1057_H_model.csv        model_1449_H_model.csv
model_1057_H_output_data.csv  model_1449_H_output_data.csv
model_1058_H_model.csv        model_144_H_model.csv
model_1058_H_output_data.csv  model_144_H_output_data.csv
model_1059_H_model.csv        model_1450_H_model.csv
model_1059_H_output_data.csv  model_1450_H_output_data.csv
model_105_H_model.csv         model_1451_H_model.csv
model_105_H_output_data.csv   model_1451_H_output_data.csv
model_1060_H_model.csv        model_1452_H_model.csv
model_1060_H_output_data.csv  model_1452_H_output_data.csv
model_1061_H_model.csv        model_1453_H_model.csv
model_1061_H_output_data.csv  model_1453_H_output_data.csv
model_1062_H_model.csv        model_1454_H_model.csv
model_1062_H_output_data.csv  model_1454_H_output_data.csv
model_1063_H_model.csv        model_1455_H_model.csv
model_1063_H_output_data.csv  model_1455_H_output_data.csv
model_1064_H_model.csv        model_1456_H_model.csv
model_1064_H_output_data.csv  model_1456_H_output_data.csv
model_1065_H_model.csv        model_1457_H_model.csv
model_1065_H_output_data.csv  model_1457_H_output_data.csv
model_1066_H_model.csv        model_1458_H_model.csv
model_1066_H_output_data.csv  model_1458_H_output_data.csv
model_1067_H_model.csv        model_1459_H_model.csv
model_1067_H_output_data.csv  model_1459_H_output_data.csv
model_1068_H_model.csv        model_145_H_model.csv
model_1068_H_output_data.csv  model_145_H_output_data.csv
model_1069_H_model.csv        model_1460_H_model.csv
model_1069_H_output_data.csv  model_1460_H_output_data.csv
model_106_H_model.csv         model_1461_H_model.csv
model_106_H_output_data.csv   model_1461_H_output_data.csv
model_1070_H_model.csv        model_1462_H_model.csv
model_1070_H_output_data.csv  model_1462_H_output_data.csv
model_1071_H_model.csv        model_1463_H_model.csv
model_1071_H_output_data.csv  model_1463_H_output_data.csv
model_1072_H_model.csv        model_1464_H_model.csv
model_1072_H_output_data.csv  model_1464_H_output_data.csv
model_1073_H_model.csv        model_1465_H_model.csv
model_1073_H_output_data.csv  model_1465_H_output_data.csv
model_1074_H_model.csv        model_1466_H_model.csv
model_1074_H_output_data.csv  model_1466_H_output_data.csv
model_1075_H_model.csv        model_1467_H_model.csv
model_1075_H_output_data.csv  model_1467_H_output_data.csv
model_1076_H_model.csv        model_1468_H_model.csv
model_1076_H_output_data.csv  model_1468_H_output_data.csv
model_1077_H_model.csv        model_1469_H_model.csv
model_1077_H_output_data.csv  model_1469_H_output_data.csv
model_1078_H_model.csv        model_146_H_model.csv
model_1078_H_output_data.csv  model_146_H_output_data.csv
model_1079_H_model.csv        model_1470_H_model.csv
model_1079_H_output_data.csv  model_1470_H_output_data.csv
model_107_H_model.csv         model_1471_H_model.csv
model_107_H_output_data.csv   model_1471_H_output_data.csv
model_1080_H_model.csv        model_1472_H_model.csv
model_1080_H_output_data.csv  model_1472_H_output_data.csv
model_1081_H_model.csv        model_1473_H_model.csv
model_1081_H_output_data.csv  model_1473_H_output_data.csv
model_1082_H_model.csv        model_1474_H_model.csv
model_1082_H_output_data.csv  model_1474_H_output_data.csv
model_1083_H_model.csv        model_1475_H_model.csv
model_1083_H_output_data.csv  model_1475_H_output_data.csv
model_1084_H_model.csv        model_1476_H_model.csv
model_1084_H_output_data.csv  model_1476_H_output_data.csv
model_1085_H_model.csv        model_1477_H_model.csv
model_1085_H_output_data.csv  model_1477_H_output_data.csv
model_1086_H_model.csv        model_1478_H_model.csv
model_1086_H_output_data.csv  model_1478_H_output_data.csv
model_1087_H_model.csv        model_1479_H_model.csv
model_1087_H_output_data.csv  model_1479_H_output_data.csv
model_1088_H_model.csv        model_147_H_model.csv
model_1088_H_output_data.csv  model_147_H_output_data.csv
model_1089_H_model.csv        model_1480_H_model.csv
model_1089_H_output_data.csv  model_1480_H_output_data.csv
model_108_H_model.csv         model_1481_H_model.csv
model_108_H_output_data.csv   model_1481_H_output_data.csv
model_1090_H_model.csv        model_1482_H_model.csv
model_1090_H_output_data.csv  model_1482_H_output_data.csv
model_1091_H_model.csv        model_1483_H_model.csv
model_1091_H_output_data.csv  model_1483_H_output_data.csv
model_1092_H_model.csv        model_1484_H_model.csv
model_1092_H_output_data.csv  model_1484_H_output_data.csv
model_1093_H_model.csv        model_1485_H_model.csv
model_1093_H_output_data.csv  model_1485_H_output_data.csv
model_1094_H_model.csv        model_1486_H_model.csv
model_1094_H_output_data.csv  model_1486_H_output_data.csv
model_1095_H_model.csv        model_1487_H_model.csv
model_1095_H_output_data.csv  model_1487_H_output_data.csv
model_1096_H_model.csv        model_1488_H_model.csv
model_1096_H_output_data.csv  model_1488_H_output_data.csv
model_1097_H_model.csv        model_1489_H_model.csv
model_1097_H_output_data.csv  model_1489_H_output_data.csv
model_1098_H_model.csv        model_148_H_model.csv
model_1098_H_output_data.csv  model_148_H_output_data.csv
model_1099_H_model.csv        model_1490_H_model.csv
model_1099_H_output_data.csv  model_1490_H_output_data.csv
model_109_H_model.csv         model_1491_H_model.csv
model_109_H_output_data.csv   model_1491_H_output_data.csv
model_10_H_model.csv          model_1492_H_model.csv
model_10_H_output_data.csv    model_1492_H_output_data.csv
model_1100_H_model.csv        model_1493_H_model.csv
model_1100_H_output_data.csv  model_1493_H_output_data.csv
model_1101_H_model.csv        model_1494_H_model.csv
model_1101_H_output_data.csv  model_1494_H_output_data.csv
model_1102_H_model.csv        model_1495_H_model.csv
model_1102_H_output_data.csv  model_1495_H_output_data.csv
model_1103_H_model.csv        model_1496_H_model.csv
model_1103_H_output_data.csv  model_1496_H_output_data.csv
model_1104_H_model.csv        model_1497_H_model.csv
model_1104_H_output_data.csv  model_1497_H_output_data.csv
model_1105_H_model.csv        model_1498_H_model.csv
model_1105_H_output_data.csv  model_1498_H_output_data.csv
model_1106_H_model.csv        model_1499_H_model.csv
model_1106_H_output_data.csv  model_1499_H_output_data.csv
model_1107_H_model.csv        model_149_H_model.csv
model_1107_H_output_data.csv  model_149_H_output_data.csv
model_1108_H_model.csv        model_14_H_model.csv
model_1108_H_output_data.csv  model_14_H_output_data.csv
model_1109_H_model.csv        model_1500_H_model.csv
model_1109_H_output_data.csv  model_1500_H_output_data.csv
model_110_H_model.csv         model_1501_H_model.csv
model_110_H_output_data.csv   model_1501_H_output_data.csv
model_1110_H_model.csv        model_1502_H_model.csv
model_1110_H_output_data.csv  model_1502_H_output_data.csv
model_1111_H_model.csv        model_1503_H_model.csv
model_1111_H_output_data.csv  model_1503_H_output_data.csv
model_1112_H_model.csv        model_1504_H_model.csv
model_1112_H_output_data.csv  model_1504_H_output_data.csv
model_1113_H_model.csv        model_1505_H_model.csv
model_1113_H_output_data.csv  model_1505_H_output_data.csv
model_1114_H_model.csv        model_1506_H_model.csv
model_1114_H_output_data.csv  model_1506_H_output_data.csv
model_1115_H_model.csv        model_1507_H_model.csv
model_1115_H_output_data.csv  model_1507_H_output_data.csv
model_1116_H_model.csv        model_1508_H_model.csv
model_1116_H_output_data.csv  model_1508_H_output_data.csv
model_1117_H_model.csv        model_1509_H_model.csv
model_1117_H_output_data.csv  model_1509_H_output_data.csv
model_1118_H_model.csv        model_150_H_model.csv
model_1118_H_output_data.csv  model_150_H_output_data.csv
model_1119_H_model.csv        model_1510_H_model.csv
model_1119_H_output_data.csv  model_1510_H_output_data.csv
model_111_H_model.csv         model_1511_H_model.csv
model_111_H_output_data.csv   model_1511_H_output_data.csv
model_1120_H_model.csv        model_1512_H_model.csv
model_1120_H_output_data.csv  model_1512_H_output_data.csv
model_1121_H_model.csv        model_1513_H_model.csv
model_1121_H_output_data.csv  model_1513_H_output_data.csv
model_1122_H_model.csv        model_1514_H_model.csv
model_1122_H_output_data.csv  model_1514_H_output_data.csv
model_1123_H_model.csv        model_1515_H_model.csv
model_1123_H_output_data.csv  model_1515_H_output_data.csv
model_1124_H_model.csv        model_1516_H_model.csv
model_1124_H_output_data.csv  model_1516_H_output_data.csv
model_1125_H_model.csv        model_1517_H_model.csv
model_1125_H_output_data.csv  model_1517_H_output_data.csv
model_1126_H_model.csv        model_1518_H_model.csv
model_1126_H_output_data.csv  model_1518_H_output_data.csv
model_1127_H_model.csv        model_1519_H_model.csv
model_1127_H_output_data.csv  model_1519_H_output_data.csv
model_1128_H_model.csv        model_151_H_model.csv
model_1128_H_output_data.csv  model_151_H_output_data.csv
model_1129_H_model.csv        model_1520_H_model.csv
model_1129_H_output_data.csv  model_1520_H_output_data.csv
model_112_H_model.csv         model_1521_H_model.csv
model_112_H_output_data.csv   model_1521_H_output_data.csv
model_1130_H_model.csv        model_1522_H_model.csv
model_1130_H_output_data.csv  model_1522_H_output_data.csv
model_1131_H_model.csv        model_1523_H_model.csv
model_1131_H_output_data.csv  model_1523_H_output_data.csv
model_1132_H_model.csv        model_1524_H_model.csv
model_1132_H_output_data.csv  model_1524_H_output_data.csv
model_1133_H_model.csv        model_1525_H_model.csv
model_1133_H_output_data.csv  model_1525_H_output_data.csv
model_1134_H_model.csv        model_1526_H_model.csv
model_1134_H_output_data.csv  model_1526_H_output_data.csv
model_1135_H_model.csv        model_1527_H_model.csv
model_1135_H_output_data.csv  model_1527_H_output_data.csv
model_1136_H_model.csv        model_1528_H_model.csv
model_1136_H_output_data.csv  model_1528_H_output_data.csv
model_1137_H_model.csv        model_1529_H_model.csv
model_1137_H_output_data.csv  model_1529_H_output_data.csv
model_1138_H_model.csv        model_152_H_model.csv
model_1138_H_output_data.csv  model_152_H_output_data.csv
model_1139_H_model.csv        model_1530_H_model.csv
model_1139_H_output_data.csv  model_1530_H_output_data.csv
model_113_H_model.csv         model_1531_H_model.csv
model_113_H_output_data.csv   model_1531_H_output_data.csv
model_1140_H_model.csv        model_1532_H_model.csv
model_1140_H_output_data.csv  model_1532_H_output_data.csv
model_1141_H_model.csv        model_1533_H_model.csv
model_1141_H_output_data.csv  model_1533_H_output_data.csv
model_1142_H_model.csv        model_1534_H_model.csv
model_1142_H_output_data.csv  model_1534_H_output_data.csv
model_1143_H_model.csv        model_1535_H_model.csv
model_1143_H_output_data.csv  model_1535_H_output_data.csv
model_1144_H_model.csv        model_1536_H_model.csv
model_1144_H_output_data.csv  model_1536_H_output_data.csv
model_1145_H_model.csv        model_1537_H_model.csv
model_1145_H_output_data.csv  model_1537_H_output_data.csv
model_1146_H_model.csv        model_1538_H_model.csv
model_1146_H_output_data.csv  model_1538_H_output_data.csv
model_1147_H_model.csv        model_1539_H_model.csv
model_1147_H_output_data.csv  model_1539_H_output_data.csv
model_1148_H_model.csv        model_153_H_model.csv
model_1148_H_output_data.csv  model_153_H_output_data.csv
model_1149_H_model.csv        model_1540_H_model.csv
model_1149_H_output_data.csv  model_1540_H_output_data.csv
model_114_H_model.csv         model_1541_H_model.csv
model_114_H_output_data.csv   model_1541_H_output_data.csv
model_1150_H_model.csv        model_1542_H_model.csv
model_1150_H_output_data.csv  model_1542_H_output_data.csv
model_1151_H_model.csv        model_1543_H_model.csv
model_1151_H_output_data.csv  model_1543_H_output_data.csv
model_1152_H_model.csv        model_1544_H_model.csv
model_1152_H_output_data.csv  model_1544_H_output_data.csv
model_1153_H_model.csv        model_1545_H_model.csv
model_1153_H_output_data.csv  model_1545_H_output_data.csv
model_1154_H_model.csv        model_1546_H_model.csv
model_1154_H_output_data.csv  model_1546_H_output_data.csv
model_1155_H_model.csv        model_1547_H_model.csv
model_1155_H_output_data.csv  model_1547_H_output_data.csv
model_1156_H_model.csv        model_1548_H_model.csv
model_1156_H_output_data.csv  model_1548_H_output_data.csv
model_1157_H_model.csv        model_1549_H_model.csv
model_1157_H_output_data.csv  model_1549_H_output_data.csv
model_1158_H_model.csv        model_154_H_model.csv
model_1158_H_output_data.csv  model_154_H_output_data.csv
model_1159_H_model.csv        model_1550_H_model.csv
model_1159_H_output_data.csv  model_1550_H_output_data.csv
model_115_H_model.csv         model_1551_H_model.csv
model_115_H_output_data.csv   model_1551_H_output_data.csv
model_1160_H_model.csv        model_1552_H_model.csv
model_1160_H_output_data.csv  model_1552_H_output_data.csv
model_1161_H_model.csv        model_1553_H_model.csv
model_1161_H_output_data.csv  model_1553_H_output_data.csv
model_1162_H_model.csv        model_1554_H_model.csv
model_1162_H_output_data.csv  model_1554_H_output_data.csv
model_1163_H_model.csv        model_1555_H_model.csv
model_1163_H_output_data.csv  model_1555_H_output_data.csv
model_1164_H_model.csv        model_1556_H_model.csv
model_1164_H_output_data.csv  model_1556_H_output_data.csv
model_1165_H_model.csv        model_1557_H_model.csv
model_1165_H_output_data.csv  model_1557_H_output_data.csv
model_1166_H_model.csv        model_1558_H_model.csv
model_1166_H_output_data.csv  model_1558_H_output_data.csv
model_1167_H_model.csv        model_1559_H_model.csv
model_1167_H_output_data.csv  model_1559_H_output_data.csv
model_1168_H_model.csv        model_155_H_model.csv
model_1168_H_output_data.csv  model_155_H_output_data.csv
model_1169_H_model.csv        model_1560_H_model.csv
model_1169_H_output_data.csv  model_1560_H_output_data.csv
model_116_H_model.csv         model_1561_H_model.csv
model_116_H_output_data.csv   model_1561_H_output_data.csv
model_1170_H_model.csv        model_1562_H_model.csv
model_1170_H_output_data.csv  model_1562_H_output_data.csv
model_1171_H_model.csv        model_1563_H_model.csv
model_1171_H_output_data.csv  model_1563_H_output_data.csv
model_1172_H_model.csv        model_1564_H_model.csv
model_1172_H_output_data.csv  model_1564_H_output_data.csv
model_1173_H_model.csv        model_1565_H_model.csv
model_1173_H_output_data.csv  model_1565_H_output_data.csv
model_1174_H_model.csv        model_1566_H_model.csv
model_1174_H_output_data.csv  model_1566_H_output_data.csv
model_1175_H_model.csv        model_1567_H_model.csv
model_1175_H_output_data.csv  model_1567_H_output_data.csv
model_1176_H_model.csv        model_1568_H_model.csv
model_1176_H_output_data.csv  model_1568_H_output_data.csv
model_1177_H_model.csv        model_1569_H_model.csv
model_1177_H_output_data.csv  model_1569_H_output_data.csv
model_1178_H_model.csv        model_156_H_model.csv
model_1178_H_output_data.csv  model_156_H_output_data.csv
model_1179_H_model.csv        model_1570_H_model.csv
model_1179_H_output_data.csv  model_1570_H_output_data.csv
model_117_H_model.csv         model_1571_H_model.csv
model_117_H_output_data.csv   model_1571_H_output_data.csv
model_1180_H_model.csv        model_1572_H_model.csv
model_1180_H_output_data.csv  model_1572_H_output_data.csv
model_1181_H_model.csv        model_1573_H_model.csv
model_1181_H_output_data.csv  model_1573_H_output_data.csv
model_1182_H_model.csv        model_1574_H_model.csv
model_1182_H_output_data.csv  model_1574_H_output_data.csv
model_1183_H_model.csv        model_1575_H_model.csv
model_1183_H_output_data.csv  model_1575_H_output_data.csv
model_1184_H_model.csv        model_1576_H_model.csv
model_1184_H_output_data.csv  model_1576_H_output_data.csv
model_1185_H_model.csv        model_1577_H_model.csv
model_1185_H_output_data.csv  model_1577_H_output_data.csv
model_1186_H_model.csv        model_1578_H_model.csv
model_1186_H_output_data.csv  model_1578_H_output_data.csv
model_1187_H_model.csv        model_1579_H_model.csv
model_1187_H_output_data.csv  model_1579_H_output_data.csv
model_1188_H_model.csv        model_157_H_model.csv
model_1188_H_output_data.csv  model_157_H_output_data.csv
model_1189_H_model.csv        model_1580_H_model.csv
model_1189_H_output_data.csv  model_1580_H_output_data.csv
model_118_H_model.csv         model_1581_H_model.csv
model_118_H_output_data.csv   model_1581_H_output_data.csv
model_1190_H_model.csv        model_1582_H_model.csv
model_1190_H_output_data.csv  model_1582_H_output_data.csv
model_1191_H_model.csv        model_1583_H_model.csv
model_1191_H_output_data.csv  model_1583_H_output_data.csv
model_1192_H_model.csv        model_1584_H_model.csv
model_1192_H_output_data.csv  model_1584_H_output_data.csv
model_1193_H_model.csv        model_1585_H_model.csv
model_1193_H_output_data.csv  model_1585_H_output_data.csv
model_1194_H_model.csv        model_1586_H_model.csv
model_1194_H_output_data.csv  model_1586_H_output_data.csv
model_1195_H_model.csv        model_1587_H_model.csv
model_1195_H_output_data.csv  model_1587_H_output_data.csv
model_1196_H_model.csv        model_1588_H_model.csv
model_1196_H_output_data.csv  model_1588_H_output_data.csv
model_1197_H_model.csv        model_1589_H_model.csv
model_1197_H_output_data.csv  model_1589_H_output_data.csv
model_1198_H_model.csv        model_158_H_model.csv
model_1198_H_output_data.csv  model_158_H_output_data.csv
model_1199_H_model.csv        model_1590_H_model.csv
model_1199_H_output_data.csv  model_1590_H_output_data.csv
model_119_H_model.csv         model_1591_H_model.csv
model_119_H_output_data.csv   model_1591_H_output_data.csv
model_11_H_model.csv          model_1592_H_model.csv
model_11_H_output_data.csv    model_1592_H_output_data.csv
model_1200_H_model.csv        model_1593_H_model.csv
model_1200_H_output_data.csv  model_1593_H_output_data.csv
model_1201_H_model.csv        model_1594_H_model.csv
model_1201_H_output_data.csv  model_1594_H_output_data.csv
model_1202_H_model.csv        model_1595_H_model.csv
model_1202_H_output_data.csv  model_1595_H_output_data.csv
model_1203_H_model.csv        model_1596_H_model.csv
model_1203_H_output_data.csv  model_1596_H_output_data.csv
model_1204_H_model.csv        model_1597_H_model.csv
model_1204_H_output_data.csv  model_1597_H_output_data.csv
model_1205_H_model.csv        model_1598_H_model.csv
model_1205_H_output_data.csv  model_1598_H_output_data.csv
model_1206_H_model.csv        model_1599_H_model.csv
model_1206_H_output_data.csv  model_1599_H_output_data.csv
model_1207_H_model.csv        model_159_H_model.csv
model_1207_H_output_data.csv  model_159_H_output_data.csv
model_1208_H_model.csv        model_15_H_model.csv
model_1208_H_output_data.csv  model_15_H_output_data.csv
model_1209_H_model.csv        model_1600_H_model.csv
model_1209_H_output_data.csv  model_1600_H_output_data.csv
model_120_H_model.csv         model_1601_H_model.csv
model_120_H_output_data.csv   model_1601_H_output_data.csv
model_1210_H_model.csv        model_1602_H_model.csv
model_1210_H_output_data.csv  model_1602_H_output_data.csv
model_1211_H_model.csv        model_1603_H_model.csv
model_1211_H_output_data.csv  model_1603_H_output_data.csv
model_1212_H_model.csv        model_1604_H_model.csv
model_1212_H_output_data.csv  model_1604_H_output_data.csv
model_1213_H_model.csv        model_1605_H_model.csv
model_1213_H_output_data.csv  model_1605_H_output_data.csv
model_1214_H_model.csv        model_1606_H_model.csv
model_1214_H_output_data.csv  model_1606_H_output_data.csv
model_1215_H_model.csv        model_1607_H_model.csv
model_1215_H_output_data.csv  model_1607_H_output_data.csv
model_1216_H_model.csv        model_1608_H_model.csv
model_1216_H_output_data.csv  model_1608_H_output_data.csv
model_1217_H_model.csv        model_1609_H_model.csv
model_1217_H_output_data.csv  model_1609_H_output_data.csv
model_1218_H_model.csv        model_160_H_model.csv
model_1218_H_output_data.csv  model_160_H_output_data.csv
model_1219_H_model.csv        model_1610_H_model.csv
model_1219_H_output_data.csv  model_1610_H_output_data.csv
model_121_H_model.csv         model_1611_H_model.csv
model_121_H_output_data.csv   model_1611_H_output_data.csv
model_1220_H_model.csv        model_1612_H_model.csv
model_1220_H_output_data.csv  model_1612_H_output_data.csv
model_1221_H_model.csv        model_1613_H_model.csv
model_1221_H_output_data.csv  model_1613_H_output_data.csv
model_1222_H_model.csv        model_1614_H_model.csv
model_1222_H_output_data.csv  model_1614_H_output_data.csv
model_1223_H_model.csv        model_1615_H_model.csv
model_1223_H_output_data.csv  model_1615_H_output_data.csv
model_1224_H_model.csv        model_1616_H_model.csv
model_1224_H_output_data.csv  model_1616_H_output_data.csv
model_1225_H_model.csv        model_1617_H_model.csv
model_1225_H_output_data.csv  model_1617_H_output_data.csv
model_1226_H_model.csv        model_1618_H_model.csv
model_1226_H_output_data.csv  model_1618_H_output_data.csv
model_1227_H_model.csv        model_1619_H_model.csv
model_1227_H_output_data.csv  model_1619_H_output_data.csv
model_1228_H_model.csv        model_161_H_model.csv
model_1228_H_output_data.csv  model_161_H_output_data.csv
model_1229_H_model.csv        model_1620_H_model.csv
model_1229_H_output_data.csv  model_1620_H_output_data.csv
model_122_H_model.csv         model_1621_H_model.csv
model_122_H_output_data.csv   model_1621_H_output_data.csv
model_1230_H_model.csv        model_1622_H_model.csv
model_1230_H_output_data.csv  model_1622_H_output_data.csv
model_1231_H_model.csv        model_1623_H_model.csv
model_1231_H_output_data.csv  model_1623_H_output_data.csv
model_1232_H_model.csv        model_1624_H_model.csv
model_1232_H_output_data.csv  model_1624_H_output_data.csv
model_1233_H_model.csv        model_1625_H_model.csv
model_1233_H_output_data.csv  model_1625_H_output_data.csv
model_1234_H_model.csv        model_1626_H_model.csv
model_1234_H_output_data.csv  model_1626_H_output_data.csv
model_1235_H_model.csv        model_1627_H_model.csv
model_1235_H_output_data.csv  model_1627_H_output_data.csv
model_1236_H_model.csv        model_1628_H_model.csv
model_1236_H_output_data.csv  model_1628_H_output_data.csv
model_1237_H_model.csv        model_1629_H_model.csv
model_1237_H_output_data.csv  model_1629_H_output_data.csv
model_1238_H_model.csv        model_162_H_model.csv
model_1238_H_output_data.csv  model_162_H_output_data.csv
model_1239_H_model.csv        model_1630_H_model.csv
model_1239_H_output_data.csv  model_1630_H_output_data.csv
model_123_H_model.csv         model_1631_H_model.csv
model_123_H_output_data.csv   model_1631_H_output_data.csv
model_1240_H_model.csv        model_1632_H_model.csv
model_1240_H_output_data.csv  model_1632_H_output_data.csv
model_1241_H_model.csv        model_1633_H_model.csv
model_1241_H_output_data.csv  model_1633_H_output_data.csv
model_1242_H_model.csv        model_1634_H_model.csv
model_1242_H_output_data.csv  model_1634_H_output_data.csv
model_1243_H_model.csv        model_1635_H_model.csv
model_1243_H_output_data.csv  model_1635_H_output_data.csv
model_1244_H_model.csv        model_1636_H_model.csv
model_1244_H_output_data.csv  model_1636_H_output_data.csv
model_1245_H_model.csv        model_1637_H_model.csv
model_1245_H_output_data.csv  model_1637_H_output_data.csv
model_1246_H_model.csv        model_1638_H_model.csv
model_1246_H_output_data.csv  model_1638_H_output_data.csv
model_1247_H_model.csv        model_1639_H_model.csv
model_1247_H_output_data.csv  model_1639_H_output_data.csv
model_1248_H_model.csv        model_163_H_model.csv
model_1248_H_output_data.csv  model_163_H_output_data.csv
model_1249_H_model.csv        model_1640_H_model.csv
model_1249_H_output_data.csv  model_1640_H_output_data.csv
model_124_H_model.csv         model_1641_H_model.csv
model_124_H_output_data.csv   model_1641_H_output_data.csv
model_1250_H_model.csv        model_1642_H_model.csv
model_1250_H_output_data.csv  model_1642_H_output_data.csv
model_1251_H_model.csv        model_1643_H_model.csv
model_1251_H_output_data.csv  model_1643_H_output_data.csv
model_1252_H_model.csv        model_1644_H_model.csv
model_1252_H_output_data.csv  model_1644_H_output_data.csv
model_1253_H_model.csv        model_1645_H_model.csv
model_1253_H_output_data.csv  model_1645_H_output_data.csv
model_1254_H_model.csv        model_1646_H_model.csv
model_1254_H_output_data.csv  model_1646_H_output_data.csv
model_1255_H_model.csv        model_1647_H_model.csv
model_1255_H_output_data.csv  model_1647_H_output_data.csv
model_1256_H_model.csv        model_1648_H_model.csv
model_1256_H_output_data.csv  model_1648_H_output_data.csv
model_1257_H_model.csv        model_1649_H_model.csv
model_1257_H_output_data.csv  model_1649_H_output_data.csv
model_1258_H_model.csv        model_164_H_model.csv
model_1258_H_output_data.csv  model_164_H_output_data.csv
model_1259_H_model.csv        model_1650_H_model.csv
model_1259_H_output_data.csv  model_1650_H_output_data.csv
model_125_H_model.csv         model_1651_H_model.csv
model_125_H_output_data.csv   model_1651_H_output_data.csv
model_1260_H_model.csv        model_1652_H_model.csv
model_1260_H_output_data.csv  model_1652_H_output_data.csv
model_1261_H_model.csv        model_1653_H_model.csv
model_1261_H_output_data.csv  model_1653_H_output_data.csv
model_1262_H_model.csv        model_1654_H_model.csv
model_1262_H_output_data.csv  model_1654_H_output_data.csv
model_1263_H_model.csv        model_1655_H_model.csv
model_1263_H_output_data.csv  model_1655_H_output_data.csv
model_1264_H_model.csv        model_1656_H_model.csv
model_1264_H_output_data.csv  model_1656_H_output_data.csv
model_1265_H_model.csv        model_1657_H_model.csv
model_1265_H_output_data.csv  model_1657_H_output_data.csv
model_1266_H_model.csv        model_1658_H_model.csv
model_1266_H_output_data.csv  model_1658_H_output_data.csv
model_1267_H_model.csv        model_1659_H_model.csv
model_1267_H_output_data.csv  model_1659_H_output_data.csv
model_1268_H_model.csv        model_165_H_model.csv
model_1268_H_output_data.csv  model_165_H_output_data.csv
model_1269_H_model.csv        model_1660_H_model.csv
model_1269_H_output_data.csv  model_1660_H_output_data.csv
model_126_H_model.csv         model_1661_H_model.csv
model_126_H_output_data.csv   model_1661_H_output_data.csv
model_1270_H_model.csv        model_1662_H_model.csv
model_1270_H_output_data.csv  model_1662_H_output_data.csv
model_1271_H_model.csv        model_1663_H_model.csv
model_1271_H_output_data.csv  model_1663_H_output_data.csv
model_1272_H_model.csv        model_1664_H_model.csv
model_1272_H_output_data.csv  model_1664_H_output_data.csv
model_1273_H_model.csv        model_1665_H_model.csv
model_1273_H_output_data.csv  model_1665_H_output_data.csv
model_1274_H_model.csv        model_1666_H_model.csv
model_1274_H_output_data.csv  model_1666_H_output_data.csv
model_1275_H_model.csv        model_1667_H_model.csv
model_1275_H_output_data.csv  model_1667_H_output_data.csv
model_1276_H_model.csv        model_1668_H_model.csv
model_1276_H_output_data.csv  model_1668_H_output_data.csv
model_1277_H_model.csv        model_1669_H_model.csv
model_1277_H_output_data.csv  model_1669_H_output_data.csv
model_1278_H_model.csv        model_166_H_model.csv
model_1278_H_output_data.csv  model_166_H_output_data.csv
model_1279_H_model.csv        model_1670_H_model.csv
model_1279_H_output_data.csv  model_1670_H_output_data.csv
model_127_H_model.csv         model_1671_H_model.csv
model_127_H_output_data.csv   model_1671_H_output_data.csv
model_1280_H_model.csv        model_1672_H_model.csv
model_1280_H_output_data.csv  model_1672_H_output_data.csv
model_1281_H_model.csv        model_1673_H_model.csv
model_1281_H_output_data.csv  model_1673_H_output_data.csv
model_1282_H_model.csv        model_1674_H_model.csv
model_1282_H_output_data.csv  model_1674_H_output_data.csv
model_1283_H_model.csv        model_1675_H_model.csv
model_1283_H_output_data.csv  model_1675_H_output_data.csv
model_1284_H_model.csv        model_1676_H_model.csv
model_1284_H_output_data.csv  model_1676_H_output_data.csv
model_1285_H_model.csv        model_1677_H_model.csv
model_1285_H_output_data.csv  model_1677_H_output_data.csv
model_1286_H_model.csv        model_1678_H_model.csv
model_1286_H_output_data.csv  model_1678_H_output_data.csv
model_1287_H_model.csv        model_1679_H_model.csv
model_1287_H_output_data.csv  model_1679_H_output_data.csv
model_1288_H_model.csv        model_167_H_model.csv
model_1288_H_output_data.csv  model_167_H_output_data.csv
model_1289_H_model.csv        model_1680_H_model.csv
model_1289_H_output_data.csv  model_1680_H_output_data.csv
model_128_H_model.csv         model_1681_H_model.csv
model_128_H_output_data.csv   model_1681_H_output_data.csv
model_1290_H_model.csv        model_1682_H_model.csv
model_1290_H_output_data.csv  model_1682_H_output_data.csv
model_1291_H_model.csv        model_1683_H_model.csv
model_1291_H_output_data.csv  model_1683_H_output_data.csv
model_1292_H_model.csv        model_1684_H_model.csv
model_1292_H_output_data.csv  model_1684_H_output_data.csv
model_1293_H_model.csv        model_1685_H_model.csv
model_1293_H_output_data.csv  model_1685_H_output_data.csv
model_1294_H_model.csv        model_1686_H_model.csv
model_1294_H_output_data.csv  model_1686_H_output_data.csv
model_1295_H_model.csv        model_1687_H_model.csv
model_1295_H_output_data.csv  model_1687_H_output_data.csv
model_1296_H_model.csv        model_1688_H_model.csv
model_1296_H_output_data.csv  model_1688_H_output_data.csv
model_1297_H_model.csv        model_1689_H_model.csv
model_1297_H_output_data.csv  model_1689_H_output_data.csv
model_1298_H_model.csv        model_168_H_model.csv
model_1298_H_output_data.csv  model_168_H_output_data.csv
model_1299_H_model.csv        model_1690_H_model.csv
model_1299_H_output_data.csv  model_1690_H_output_data.csv
model_129_H_model.csv         model_1691_H_model.csv
model_129_H_output_data.csv   model_1691_H_output_data.csv
model_12_H_model.csv          model_1692_H_model.csv
model_12_H_output_data.csv    model_1692_H_output_data.csv
model_1300_H_model.csv        model_1693_H_model.csv
model_1300_H_output_data.csv  model_1693_H_output_data.csv
model_1301_H_model.csv        model_1694_H_model.csv
model_1301_H_output_data.csv  model_1694_H_output_data.csv
model_1302_H_model.csv        model_1695_H_model.csv
model_1302_H_output_data.csv  model_1695_H_output_data.csv
model_1303_H_model.csv        model_1696_H_model.csv
model_1303_H_output_data.csv  model_1696_H_output_data.csv
model_1304_H_model.csv        model_1697_H_model.csv
model_1304_H_output_data.csv  model_1697_H_output_data.csv
model_1305_H_model.csv        model_1698_H_model.csv
model_1305_H_output_data.csv  model_1698_H_output_data.csv
model_1306_H_model.csv        model_1699_H_model.csv
model_1306_H_output_data.csv  model_1699_H_output_data.csv
model_1307_H_model.csv        model_169_H_model.csv
model_1307_H_output_data.csv  model_169_H_output_data.csv
model_1308_H_model.csv        model_16_H_model.csv
model_1308_H_output_data.csv  model_16_H_output_data.csv
model_1309_H_model.csv        model_1700_H_model.csv
model_1309_H_output_data.csv  model_1700_H_output_data.csv
model_130_H_model.csv         model_1701_H_model.csv
model_130_H_output_data.csv   model_1701_H_output_data.csv
model_1310_H_model.csv        model_1702_H_model.csv
model_1310_H_output_data.csv  model_1702_H_output_data.csv
model_1311_H_model.csv        model_1703_H_model.csv
model_1311_H_output_data.csv  model_1703_H_output_data.csv
model_1312_H_model.csv        model_1704_H_model.csv
model_1312_H_output_data.csv  model_1704_H_output_data.csv
model_1313_H_model.csv        model_1705_H_model.csv
model_1313_H_output_data.csv  model_1705_H_output_data.csv
model_1314_H_model.csv        model_1706_H_model.csv
model_1314_H_output_data.csv  model_1706_H_output_data.csv
model_1315_H_model.csv        model_1707_H_model.csv
model_1315_H_output_data.csv  model_1707_H_output_data.csv
model_1316_H_model.csv        model_1708_H_model.csv
model_1316_H_output_data.csv  model_1708_H_output_data.csv
model_1317_H_model.csv        model_1709_H_model.csv
model_1317_H_output_data.csv  model_1709_H_output_data.csv
model_1318_H_model.csv        model_170_H_model.csv
model_1318_H_output_data.csv  model_170_H_output_data.csv
model_1319_H_model.csv        model_1710_H_model.csv
model_1319_H_output_data.csv  model_1710_H_output_data.csv
model_131_H_model.csv         model_1711_H_model.csv
model_131_H_output_data.csv   model_1711_H_output_data.csv
model_1320_H_model.csv        model_1712_H_model.csv
model_1320_H_output_data.csv  model_1712_H_output_data.csv
model_1321_H_model.csv        model_1713_H_model.csv
model_1321_H_output_data.csv  model_1713_H_output_data.csv
model_1322_H_model.csv        model_1714_H_model.csv
model_1322_H_output_data.csv  model_1714_H_output_data.csv
model_1323_H_model.csv        model_1715_H_model.csv
model_1323_H_output_data.csv  model_1715_H_output_data.csv
model_1324_H_model.csv        model_1716_H_model.csv
model_1324_H_output_data.csv  model_1716_H_output_data.csv
model_1325_H_model.csv        model_1717_H_model.csv
model_1325_H_output_data.csv  model_1717_H_output_data.csv
model_1326_H_model.csv        model_1718_H_model.csv
model_1326_H_output_data.csv  model_1718_H_output_data.csv
model_1327_H_model.csv        model_1719_H_model.csv
model_1327_H_output_data.csv  model_1719_H_output_data.csv
model_1328_H_model.csv        model_171_H_model.csv
model_1328_H_output_data.csv  model_171_H_output_data.csv
model_1329_H_model.csv        model_1720_H_model.csv
model_1329_H_output_data.csv  model_1720_H_output_data.csv
model_132_H_model.csv         model_1721_H_model.csv
model_132_H_output_data.csv   model_1721_H_output_data.csv
model_1330_H_model.csv        model_1722_H_model.csv
model_1330_H_output_data.csv  model_1722_H_output_data.csv
model_1331_H_model.csv        model_1723_H_model.csv
model_1331_H_output_data.csv  model_1723_H_output_data.csv
model_1332_H_model.csv        model_1724_H_model.csv
model_1332_H_output_data.csv  model_1724_H_output_data.csv
model_1333_H_model.csv        model_1725_H_model.csv
model_1333_H_output_data.csv  model_1725_H_output_data.csv
model_1334_H_model.csv        model_1726_H_model.csv
model_1334_H_output_data.csv  model_1726_H_output_data.csv
model_1335_H_model.csv        model_1727_H_model.csv
model_1335_H_output_data.csv  model_1727_H_output_data.csv
model_1336_H_model.csv        model_1728_H_model.csv
model_1336_H_output_data.csv  model_1728_H_output_data.csv
model_1337_H_model.csv        model_1729_H_model.csv
model_1337_H_output_data.csv  model_1729_H_output_data.csv
model_1338_H_model.csv        model_172_H_model.csv
model_1338_H_output_data.csv  model_172_H_output_data.csv
model_1339_H_model.csv        model_1730_H_model.csv
model_1339_H_output_data.csv  model_1730_H_output_data.csv
model_133_H_model.csv         model_1731_H_model.csv
model_133_H_output_data.csv   model_1731_H_output_data.csv
model_1340_H_model.csv        model_1732_H_model.csv
model_1340_H_output_data.csv  model_1732_H_output_data.csv
model_1341_H_model.csv        model_1733_H_model.csv
model_1341_H_output_data.csv  model_1733_H_output_data.csv
model_1342_H_model.csv        model_1734_H_model.csv
model_1342_H_output_data.csv  model_1734_H_output_data.csv
model_1343_H_model.csv        model_1735_H_model.csv
model_1343_H_output_data.csv  model_1735_H_output_data.csv
model_1344_H_model.csv        model_1736_H_model.csv
model_1344_H_output_data.csv  model_1736_H_output_data.csv
model_1345_H_model.csv        model_1737_H_model.csv
model_1345_H_output_data.csv  model_1737_H_output_data.csv
model_1346_H_model.csv        model_1738_H_model.csv
model_1346_H_output_data.csv  model_1738_H_output_data.csv
model_1347_H_model.csv        model_1739_H_model.csv
model_1347_H_output_data.csv  model_1739_H_output_data.csv
model_1348_H_model.csv        model_173_H_model.csv
model_1348_H_output_data.csv  model_173_H_output_data.csv
model_1349_H_model.csv        model_1740_H_model.csv
model_1349_H_output_data.csv  model_1740_H_output_data.csv
model_134_H_model.csv         model_1741_H_model.csv
model_134_H_output_data.csv   model_1741_H_output_data.csv
model_1350_H_model.csv        model_1742_H_model.csv
model_1350_H_output_data.csv  model_1742_H_output_data.csv
model_1351_H_model.csv        model_1743_H_model.csv
model_1351_H_output_data.csv  model_1743_H_output_data.csv
model_1352_H_model.csv        model_1744_H_model.csv
model_1352_H_output_data.csv  model_1744_H_output_data.csv
model_1353_H_model.csv        model_1745_H_model.csv
model_1353_H_output_data.csv  model_1745_H_output_data.csv
model_1354_H_model.csv        model_1746_H_model.csv
model_1354_H_output_data.csv  model_1746_H_output_data.csv
model_1355_H_model.csv        model_1747_H_model.csv
model_1355_H_output_data.csv  model_1747_H_output_data.csv
model_1356_H_model.csv        model_1748_H_model.csv
model_1356_H_output_data.csv  model_1748_H_output_data.csv
model_1357_H_model.csv        model_1749_H_model.csv
model_1357_H_output_data.csv  model_1749_H_output_data.csv
model_1358_H_model.csv        model_174_H_model.csv
model_1358_H_output_data.csv  model_174_H_output_data.csv
model_1359_H_model.csv        model_1750_H_model.csv
model_1359_H_output_data.csv  model_1750_H_output_data.csv
model_135_H_model.csv         model_1751_H_model.csv
model_135_H_output_data.csv   model_1751_H_output_data.csv
model_1360_H_model.csv        model_1752_H_model.csv
model_1360_H_output_data.csv  model_1752_H_output_data.csv
model_1361_H_model.csv        model_1753_H_model.csv
model_1361_H_output_data.csv  model_1753_H_output_data.csv
model_1362_H_model.csv        model_1754_H_model.csv
model_1362_H_output_data.csv  model_1754_H_output_data.csv
model_1363_H_model.csv        model_1755_H_model.csv
model_1363_H_output_data.csv  model_1755_H_output_data.csv
model_1364_H_model.csv        model_1756_H_model.csv
model_1364_H_output_data.csv  model_1756_H_output_data.csv
model_1365_H_model.csv        model_1757_H_model.csv
model_1365_H_output_data.csv  model_1757_H_output_data.csv
model_1366_H_model.csv        model_1758_H_model.csv
model_1366_H_output_data.csv  model_1758_H_output_data.csv
model_1367_H_model.csv        model_1759_H_model.csv
model_1367_H_output_data.csv  model_1759_H_output_data.csv
model_1368_H_model.csv        model_175_H_model.csv
model_1368_H_output_data.csv  model_175_H_output_data.csv
model_1369_H_model.csv        model_1760_H_model.csv
model_1369_H_output_data.csv  model_1760_H_output_data.csv
model_136_H_model.csv         model_1761_H_model.csv
model_136_H_output_data.csv   model_1761_H_output_data.csv
model_1370_H_model.csv        model_1762_H_model.csv
model_1370_H_output_data.csv  model_1762_H_output_data.csv
model_1371_H_model.csv        model_1763_H_model.csv
model_1371_H_output_data.csv  model_1763_H_output_data.csv
model_1372_H_model.csv        model_1764_H_model.csv
model_1372_H_output_data.csv  model_1764_H_output_data.csv
model_1373_H_model.csv        model_1765_H_model.csv
model_1373_H_output_data.csv  model_1765_H_output_data.csv
model_1374_H_model.csv        model_1766_H_model.csv
model_1374_H_output_data.csv  model_1766_H_output_data.csv
model_1375_H_model.csv        model_1767_H_model.csv
model_1375_H_output_data.csv  model_1767_H_output_data.csv
model_1376_H_model.csv        model_1768_H_model.csv
model_1376_H_output_data.csv  model_1768_H_output_data.csv
model_1377_H_model.csv        model_1769_H_model.csv
model_1377_H_output_data.csv  model_1769_H_output_data.csv
model_1378_H_model.csv        model_176_H_model.csv
model_1378_H_output_data.csv  model_176_H_output_data.csv
model_1379_H_model.csv        model_1770_H_model.csv
model_1379_H_output_data.csv  model_1770_H_output_data.csv
model_137_H_model.csv         model_1771_H_model.csv
model_137_H_output_data.csv   model_1771_H_output_data.csv
model_1380_H_model.csv        model_1772_H_model.csv
model_1380_H_output_data.csv  model_1772_H_output_data.csv
model_1381_H_model.csv        model_1773_H_model.csv
model_1381_H_output_data.csv  model_1773_H_output_data.csv
model_1382_H_model.csv        model_1774_H_model.csv
model_1382_H_output_data.csv  model_1774_H_output_data.csv
model_1383_H_model.csv        model_1775_H_model.csv
model_1383_H_output_data.csv  model_1775_H_output_data.csv
model_1384_H_model.csv        model_1776_H_model.csv
model_1384_H_output_data.csv  model_1776_H_output_data.csv
model_1385_H_model.csv        model_1777_H_model.csv
model_1385_H_output_data.csv  model_1777_H_output_data.csv
model_1386_H_model.csv        model_1778_H_model.csv
model_1386_H_output_data.csv  model_1778_H_output_data.csv
model_1387_H_model.csv        model_1779_H_model.csv
model_1387_H_output_data.csv  model_1779_H_output_data.csv
model_1388_H_model.csv        model_177_H_model.csv
model_1388_H_output_data.csv  model_177_H_output_data.csv
model_1389_H_model.csv        model_1780_H_model.csv
model_1389_H_output_data.csv  model_1780_H_output_data.csv
model_138_H_model.csv         model_1781_H_model.csv
model_138_H_output_data.csv   model_1781_H_output_data.csv
model_1390_H_model.csv        model_1782_H_model.csv
model_1390_H_output_data.csv  model_1782_H_output_data.csv
model_1391_H_model.csv        model_1783_H_model.csv
model_1391_H_output_data.csv  model_1783_H_output_data.csv
model_1392_H_model.csv        Sharad_Ideal_matchedFilter.csv*
model_1392_H_output_data.csv  Sharad_Ideal_sourcePulse.csv*

import os
from glob import glob
import pandas as pd
import numpy as np

# Initializing the two input parameters for the Scikit-Learn MLPClassifier function
models = []
labels = []

modelPlaceholder = pd.DataFrame()
labelPlaceholder = pd.DataFrame()


for file in glob(os.getcwd()+"/*model.csv"):
    num = glob(file)[0].rsplit('_', 1)[0].rsplit('/', 1)[1].rsplit('_', 1)[0].rsplit('_', 1)[1]
    model = pd.read_csv(glob("*"+str(num)+"*output*.csv")[0], index_col=None, header=0)
    trainLabs = pd.read_csv(file.rsplit('/', 1)[1], index_col=None, header=0)
    if len(trainLabs) == 1:
        # Some of the models didn't fully generate data as I manually stopped the shell script. The end result
        # is that I need to ignore those models. This ignores all models that did not fully generate their
        # training labels.
        pass
    else:
        # Grabbing just the reflection rows (ignoring model-generated data above the ice, and below the final layer interface)
        model["Distance"] = (model["Time (s)"]*(3e8))/(2*np.sqrt(3.1))
        surfaceIndex = int(model.loc[model["Distance"] >= 0].index[0])
        basalIndex = int(model.loc[model["Distance"] >= 2000].index[0])
        model = model.loc[surfaceIndex:basalIndex,]
        
        # Labeling layers
        model["Layer Interface"] = model["Distance"].apply(lambda x: True if round(x) % (trainLabs["Depth (m)"][1]-trainLabs["Depth (m)"][0]) == 0 else False) 

        # Adding to model placeholder variable
        modelPlaceholder[str(num)] = model["power (dB)"]
        labelPlaceholder[str(num)] = model["Layer Interface"]
 
modelPlaceholder = modelPlaceholder.fillna(0)
labelPlaceholder = labelPlaceholder.fillna(0)

/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]
/tmp/ipykernel_262711/2152042525.py:34: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  modelPlaceholder[str(num)] = model["power (dB)"]
/tmp/ipykernel_262711/2152042525.py:35: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`
  labelPlaceholder[str(num)] = model["Layer Interface"]

Since the data is "fragmented" I am making .copy() objects of the placeholders:

models = modelPlaceholder.copy()
labels = labelPlaceholder.copy()
print(models,labels)

            916        351        694        880        660        471  \
2125  -0.059591  -0.059988  -0.059591  -0.059591  -0.059692  -0.059591   
2126  -0.238738  -0.239573  -0.238738  -0.238738  -0.238967  -0.238738   
2127  -0.538582  -0.539881  -0.538582  -0.538582  -0.538964  -0.538582   
2128  -0.961064  -0.962837  -0.961064  -0.961064  -0.961623  -0.961064   
2129  -1.508996  -1.511236  -1.508996  -1.508996  -1.509751  -1.508996   
...         ...        ...        ...        ...        ...        ...   
3295 -51.572928 -50.892849 -51.572928 -51.572928 -51.044625 -51.572928   
3296 -52.464952 -51.795110 -52.464952 -52.464952 -51.896864 -52.464952   
3297 -53.737978 -53.072783 -53.737978 -53.737978 -53.109533 -53.737978   
3298 -55.536071 -54.867483 -55.536071 -55.536071 -54.810444 -55.536071   
3299 -58.146564 -57.459295 -58.146564 -58.146564 -57.245285 -58.146564   

            289        311        897        860  ...        837        213  \
2125  -0.059591  -0.059591  -0.059498  -0.059596  ...  -0.059591  -0.059591   
2126  -0.238738  -0.238738  -0.238578  -0.238747  ...  -0.238738  -0.238738   
2127  -0.538582  -0.538582  -0.538380  -0.538586  ...  -0.538582  -0.538582   
2128  -0.961064  -0.961064  -0.960847  -0.961046  ...  -0.961064  -0.961064   
2129  -1.508996  -1.508996  -1.508794  -1.508931  ...  -1.508996  -1.508996   
...         ...        ...        ...        ...  ...        ...        ...   
3295 -51.572928 -51.572928 -51.628599 -51.375331  ... -51.572928 -51.572928   
3296 -52.464952 -52.464952 -52.519744 -52.266220  ... -52.464952 -52.464952   
3297 -53.737978 -53.737978 -53.800219 -53.528529  ... -53.737978 -53.737978   
3298 -55.536071 -55.536071 -55.622609 -55.300750  ... -55.536071 -55.536071   
3299 -58.146564 -58.146564 -58.300131 -57.856609  ... -58.146564 -58.146564   

            629        552        840        467        313        659  \
2125  -0.059591  -0.059591  -0.059591  -0.059591  -0.059591  -0.059591   
2126  -0.238738  -0.238738  -0.238738  -0.238738  -0.238738  -0.238738   
2127  -0.538582  -0.538582  -0.538582  -0.538582  -0.538582  -0.538582   
2128  -0.961064  -0.961064  -0.961064  -0.961064  -0.961064  -0.961064   
2129  -1.508996  -1.508996  -1.508996  -1.508996  -1.508996  -1.508996   
...         ...        ...        ...        ...        ...        ...   
3295 -51.572928 -51.572928 -51.572928 -51.572928 -51.572928 -51.572928   
3296 -52.464952 -52.464952 -52.464952 -52.464952 -52.464952 -52.464952   
3297 -53.737978 -53.737978 -53.737978 -53.737978 -53.737978 -53.737978   
3298 -55.536071 -55.536071 -55.536071 -55.536071 -55.536071 -55.536071   
3299 -58.146564 -58.146564 -58.146564 -58.146564 -58.146564 -58.146564   

            805        710  
2125  -0.059593  -0.059523  
2126  -0.238712  -0.238644  
2127  -0.538498  -0.538501  
2128  -0.960898  -0.961034  
2129  -1.508727  -1.509050  
...         ...        ...  
3295 -51.838584 -51.117287  
3296 -52.736204 -51.986805  
3297 -54.022413 -53.223457  
3298 -55.846936 -54.960052  
3299 -58.514457 -57.456847  

[1175 rows x 997 columns]         916    351    694    880    660    471    289    311    897    860  \
2125  False  False  False  False  False  False  False  False  False  False   
2126  False  False  False  False  False  False  False  False  False  False   
2127  False  False  False  False  False  False  False  False  False  False   
2128  False  False  False  False  False  False  False  False  False  False   
2129  False  False  False  False  False  False  False  False  False  False   
...     ...    ...    ...    ...    ...    ...    ...    ...    ...    ...   
3295  False  False  False  False  False  False  False  False  False  False   
3296  False  False  False  False  False  False  False  False  False  False   
3297  False  False  False  False  False  False  False  False  False  False   
3298  False  False  False  False  False  False  False  False  False  False   
3299  False  False  False  False  False  False  False  False  False  False   

      ...    837    213    629    552    840    467    313    659    805  \
2125  ...  False  False  False  False  False  False  False  False  False   
2126  ...  False  False  False  False  False  False  False  False  False   
2127  ...  False  False  False  False  False  False  False  False  False   
2128  ...  False  False  False  False  False  False  False  False  False   
2129  ...  False  False  False  False  False  False  False  False  False   
...   ...    ...    ...    ...    ...    ...    ...    ...    ...    ...   
3295  ...  False  False  False  False  False  False  False  False  False   
3296  ...  False  False  False  False  False  False  False  False  False   
3297  ...  False  False  False  False  False  False  False  False  False   
3298  ...  False  False  False  False  False  False  False  False  False   
3299  ...  False  False  False  False  False  False  False  False  False   

        710  
2125  False  
2126  False  
2127  False  
2128  False  
2129  False  
...     ...  
3295  False  
3296  False  
3297  False  
3298  False  
3299  False  

[1175 rows x 997 columns]

from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix

clf = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(15,), random_state=1, max_iter=1000)

clf.fit(models,labels)
MLPClassifier(alpha=1e-05, hidden_layer_sizes=(15,), random_state=1, solver='lbfgs', max_iter=1000)

MLPClassifier(alpha=1e-05, hidden_layer_sizes=(15,), max_iter=1000,
              random_state=1, solver='lbfgs')

The "lbfgs" algorithm uses gradient descent in order to "learn". This simply means that the local minimum (i.e. the lowest difference between predicted value and actual value) is searched for.

In the interest of time, I will accept that this can be improved with more training data, but will move forward with my machine learning prediction in order to show that the pipeline itself has been completed (and out of curiosity to see how close to accurate the model can get).

In order to test this model I will generate one final model-generated dataset and then run a test off of that.

# Set to run for a series of different layer sizes
# with a depth of 2000 m,
# modelCount set to 1 so the model name isn't the same as the previously-generated training data (which went from modelCount 5-2000),
# an iteration step size of 1 m,
# a starting layer size of 20 m,
# and the bandwidth to calculate for is the high freq sub-band (20-25 MHz).
# The singleModel parameter is set to 0 so it iterates up to the depth, creating a model for ever 1 m interval.
generateModels(2000, 1, 1, 20, 2, 1)

ls *_1_*.txt

model_1_H.txt

!python radar_FM1D_refMethod.py model_1_H.txt

ls *_1_*

model_1_H_model.csv        model_1_H_output_figure.png
model_1_H_output_data.csv  model_1_H.txt

model = pd.read_csv("model_1_H_output_data.csv", index_col=None, header=0)

model["Distance"] = (model["Time (s)"]*(3e8))/(2*np.sqrt(3.1))
surfaceIndex = int(model.loc[model["Distance"] >= 0].index[0])
basalIndex = int(model.loc[model["Distance"] >= 2000].index[0])
model = model.loc[surfaceIndex:basalIndex,]
model

	Time (s)	power (dB)	amplitude (real)	amplitude (imag)	Distance
2125	1.000235e-08	0.000000	-2.326257e-06	7.858853e-07	0.852143
2126	3.000706e-08	-0.052559	1.953744e-06	-1.462684e-06	2.556430
2127	5.001177e-08	-0.204251	-1.375685e-06	1.964584e-06	4.260716
2128	7.001647e-08	-0.452530	6.733985e-07	-2.231371e-06	5.965003
2129	9.002118e-08	-0.794656	5.679134e-08	2.240028e-06	7.669289
...	...	...	...	...	...
3295	2.341551e-05	-48.349075	4.879830e-09	8.022590e-09	1994.867362
3296	2.343551e-05	-48.910990	-6.346887e-09	-6.098393e-09	1996.571648
3297	2.345552e-05	-49.854180	6.954046e-09	3.740430e-09	1998.275935
3298	2.347552e-05	-51.270556	-6.575202e-09	-1.328529e-09	1999.980221
3299	2.349553e-05	-53.311103	5.253879e-09	-7.244983e-10	2001.684508

1175 rows × 5 columns

model = model.drop(['Time (s)', 'amplitude (real)', 'amplitude (imag)', 'Distance'], axis=1)
clf.predict(model.T)

/home/abraeley/anaconda3/lib/python3.9/site-packages/sklearn/base.py:450: UserWarning: X does not have valid feature names, but MLPClassifier was fitted with feature names
  warnings.warn(

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
/tmp/ipykernel_262711/1531670052.py in <module>
      1 #model = model.drop(['Time (s)', 'amplitude (real)', 'amplitude (imag)', 'Distance'], axis=1)
----> 2 clf.predict(model.T)

~/anaconda3/lib/python3.9/site-packages/sklearn/neural_network/_multilayer_perceptron.py in predict(self, X)
   1165         """
   1166         check_is_fitted(self)
-> 1167         y_pred = self._forward_pass_fast(X)
   1168 
   1169         if self.n_outputs_ == 1:

~/anaconda3/lib/python3.9/site-packages/sklearn/neural_network/_multilayer_perceptron.py in _forward_pass_fast(self, X)
    157             The decision function of the samples for each class in the model.
    158         """
--> 159         X = self._validate_data(X, accept_sparse=["csr", "csc"], reset=False)
    160 
    161         # Initialize first layer

~/anaconda3/lib/python3.9/site-packages/sklearn/base.py in _validate_data(self, X, y, reset, validate_separately, **check_params)
    583 
    584         if not no_val_X and check_params.get("ensure_2d", True):
--> 585             self._check_n_features(X, reset=reset)
    586 
    587         return out

~/anaconda3/lib/python3.9/site-packages/sklearn/base.py in _check_n_features(self, X, reset)
    398 
    399         if n_features != self.n_features_in_:
--> 400             raise ValueError(
    401                 f"X has {n_features} features, but {self.__class__.__name__} "
    402                 f"is expecting {self.n_features_in_} features as input."

ValueError: X has 1175 features, but MLPClassifier is expecting 997 features as input.

I can see that in the process of trying to train my neural network, I encountered a new problem with my training data: since the model-generated data is not all one continuous size from the surface reflector to the basal reflector, the Scikit-Learn function gets confused.

I need to build out more of my data-processing pipeline in order fit the neural network with the same number of input parameters for all training data, as well as for testing data.

This also presents a new challenge for testing this against the raw radar data, which are always 3600 pixels in height. The distance between one pixel (vertically) to the next is not the same as one row from the model-generated data to the next row.

For future work:

My next goal in this process is to determine the best way to normalize between:

• 1) Each of the different model-generated training sets. I believe not slicing the data from surface to basal reflector rows should solve this problem, as the total row size between model-generated datasets is consistent.
• 2) Normalize between the actual SHARAD data, and the model-generated datasets.
• 3) I need to consider how this limitation can/will impact my ability to make layer predictions across a variety of actual radar data. Will I need to re-train my model in order to predict off of a specific column of pixels in a specific radargram (the surface-to-basal reflector depth changes depending on the column as well as the individual radargram)?

At that point, I will be able to again try training this neural network. I will mark the milestone of having trained the model to the point of convergence successfully, meaning that it was able to "learn" off of the parameters and labels fed in, a potentially significant milestone in being able to predict the locations of stratigraphic layers based solely off the power values of specific reflectors.

SHARAD instrument documentation:

Seu, R., Phillips, R. J., Biccari, D., Orosei, R., Masdea, A., Picardi, G., Safaeinili, A., Campbell, B. A., Plaut, J. J., Marinangeli, L., Smrekar, S. E., & Nunes, D. C. (2007). SHARAD sounding radar on the Mars Reconnaissance Orbiter. Journal of Geophysical Research, 112(E5), E05S05. https://doi.org/10.1029/2006JE002745

Background reading:

Byrne, S. (2009). The Polar Deposits of Mars. Annual Review of Earth and Planetary Sciences, 37(1), 535–560. https://doi.org/10.1146/annurev.earth.031208.100101

Smith, I. B., Hayne, P. O., Byrne, S., Becerra, P., Kahre, M., Calvin, W., ... & Horgan, B. (2020), The Holy Grail: A road map for unlocking the climate record stored within Mars’ polar layered deposits, Planet. Space Sci., 184, 104841. https://doi.org/10.1016/j.pss.2020.104841