trying to fit a peak to some data like this:
import scipy
from lmfit.models import GaussianModel
x = shm.PTR_P
y = shm.PORE_V_P
mod = LorentzianModel()
pars = mod.guess(y, x=x)
out = mod.fit(y, pars, x=x)
print(out.fit_report(min_correl=0.25))
and while I can do the fit if I generate the data, if I try to read them from another source it doesn't work. Am not too good at this and have no idea what the issue is. Here is the output:
[x,y]
[(34.145490000000002, 3.4599999999999999e-08),
(29.286449999999999, 4.8399999999999997e-08),
(25.118860000000002, 0.026773140000000001),
(21.544350000000001, 0.068791409999999997),
(18.4785, 0.083200979999999994),
(15.848929999999999, 0.02123179),
(11.659139999999999, 0.01551077),
(10.0, 0.084493879999999993),
(6.3095739999999996, 2.0899999999999998e-07),
(5.4116949999999999, 0.045209140000000002),
(4.6415889999999997, 0.054789360000000002),
(3.4145489999999996, 8.9399999999999993e-08),
(2.9286449999999999, 0.01100814),
(2.5118860000000001, 0.088990659999999999),
(1.84785, 3.5799999999999995e-07),
(1.5848930000000001, 0.099999009999999999),
(1.359356, 0.075139280000000003),
(1.1659139999999999, 0.167379),
(1.0, 0.57693050000000001),
(0.85769590000000007, 1.8658159999999999),
(0.73564230000000008, 8.4961369999999992),
(0.6309574, 25.299099999999999),
(0.54116949999999997, 21.413350000000001),
(0.46415889999999999, 13.408829999999998),
(0.39810719999999999, 8.3584750000000003),
(0.34145490000000006, 5.3982010000000002),
(0.29286440000000002, 3.7518540000000002),
(0.25118859999999998, 2.5325389999999999),
(0.21544349999999998, 1.7722470000000001),
(0.18478499999999998, 1.445808),
(0.15848929999999997, 1.182083),
(0.13593559999999999, 0.94957730000000007),
(0.1165914, 0.67620849999999999),
(0.10000000000000001, 0.46631620000000001),
(0.085769590000000007, 0.41001890000000002),
(0.07356422, 0.30625920000000001),
(0.063095730000000003, 0.24040219999999998),
(0.054116949999999997, 0.1942596),
(0.046415890000000001, 0.11306760000000002),
(0.039810720000000001, 0.099998470000000006),
(0.034145490000000001, 0.099998470000000006),
(0.029286449999999999, 0.02246857),
(0.025118870000000001, 0.077529909999999994)]
I would guess that either there are NaNs in your data or that the initial guess is so far off as to produce NaNs. The initial guess of 0 for sigma seems suspicious -- this should be > 0.
Either way, plotting the data and using np.isnan() would probably help isolate the problem.
Related
I have this code. I save weights after every epoch and the code saves it. But when I load the weights the loss value starts from the initial loss value which means the loading is failing somehow.
net = torchvision.models.resnet18(pretrained=True)
num_ftrs = net.fc.in_features
net.fc = nn.Linear(num_ftrs, 136)
def train():
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
criterion = L1Loss(reduction='sum')
lr = 0.0000001
optimizer = optim.Adam(net.parameters(), lr=lr, weight_decay=0.0005)
net.to(device)
state = torch.load('face2.txt')
net.load_state_dict(state['state_dict'])
optimizer.load_state_dict(state['optimizer'])
for epoch in range(int(0), 200000):
for batch, data in enumerate(trainloader, 0):
torch.cuda.empty_cache()
inputs, labels = data
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
outputs = net(inputs).reshape(-1, 68, 2)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
state = {
'epoch': epoch,
'state_dict': net.state_dict(),
'optimizer': optimizer.state_dict(),
}
torch.save(state, 'face2.txt')
if __name__ == '__main__':
train()
The initial loss is 50k plus and after some thousand epochs the loss becomes 50-60. Now when I re-run the code I expect it to start from a near loss value but it starts from around 50k again.
The code you wrote:
net = torchvision.models.resnet18(pretrained=True)
means you start over again with the same net - pretrained resnet18. Instead, you should load the last state if present, this would fix your problem.
I will slightly update your notation:
state = {
'epoch': epoch,
'model_state_dict': net.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
...
}
torch.save(state, filepath)
Learnable parameters are the first state_dict (model state dict).
The second state_dict is the optimizer state dict. You recall that the optimizer is used to improve our learnable parameters. But the optimizer state_dict is fixed. Nothing to learn in there.
Your code at some point should look like:
model.load_state_dict(state['model_state_dict'])
optimizer.load_state_dict(state['optimizer_state_dict'])
I am trying to follow different papers and tutorials to learn how to solve optimization problems of modelica modells.
In http://www.syscop.de/files/2015ss/events/opcon-thermal-systems/optimization_tool_chain_in_jmodelica.org_toivo_henningsson.pdf I found a very simple tutorial. But when I execute it I get some very open error messages.
I am using Python 2.7 with jupyther.
Here is my Notepad:
from pyjmi import transfer_optimization_problem
import matplotlib.pyplot as plt
import os.path
file_path = os.path.join("D:\Studies", "Integrator.mop")
op = transfer_optimization_problem('optI', file_path)
res = op.optimize()
t = res['time']
x = res['x']
u = res['u']
plt.plot(t,x,t,u)
My modelica file:
package Integrator
model Integrator
Real x(start=2, fixed = true);
input Real u;
equation
der(x) = -u;
end Integrator;
optimization optI(objective = finalTime, objectiveIntegrand = x^2 + u^2, startTime = 0, finalTime(free = true, min = 0.5, max = 2, initialGuess = 1))
Real x (start = 2, fixed = true);
input Real u;
equation
der(x) = -u;
constraint
u <= 2;
x(finalTime) = 0;
end optI;
end Integrator;
When I excute the code I get an RuntimeError, telling me that a java error occured and details where printed. From the Traceback I do not know what the note
This file is compatible with both classic and new-style classes
mean. I know that my setup is working because I executed the CSTR tutorial given by modelon. But now, it try to use my own models and it is giving me that error.
Runtime Error desciption
Using same syntax like in Modelica for import
e.g.
import Modelica.SIunits.Temperature;
where the package structure is part of the model-identification should resolve the issue.
op = transfer_optimization_problem('Integrator.optI', file_path)
Trying to sort this list from lowest (399||1) to highest value (11064||2) while conserving the provided data format to be reused in an API loop request.
As you can see below, sorted() is not working as (I) expected. This is Python 2.7.
It looks like it sorts in pieces. Why would 1000-1100 come before 300-700, and then 8000? I cannot find this same issue posted anywhere.
sorted_d = sorted(d)
print sorted_d
Run:
[u'1053||1', u'1092||2', u'1093||1', u'1094||1', u'1094||2', u'1095||1',
u'1095||2', u'1096||7', u'1096||8', u'1097||7', u'1097||8', u'11064||1',
u'11064||2', u'399||1', u'412||1', u'412||2', u'413||1', u'414||1',
u'434||2', u'616||1', u'617||1', u'618||1', u'619||1', u'620||1', u'621||1',
u'622||1', u'727||1', u'8096||1', u'8097||1', u'8099||1', u'8101||1',
u'8105||1', u'8112||1', u'8113||1', u'8140||1', u'8141||1', u'8142||1',
u'8143||1', u'8144||1', u'8146||2', u'8150||1', u'8152||1', u'8153||1',
u'8154||1', u'8157||1', u'8158||1', u'8159||1', u'8160||1', u'8161||1',
u'8162||1', u'8163||1', u'8164||1', u'8165||1', u'8166||1', u'8167||1',
u'8168||1', u'8169||1', u'8170||1', u'8171||1', u'8172||1', u'8173||1',
u'8174||1', u'8175||1', u'8184||2', u'8184||3', u'8185||2', u'8185||3',
u'8186||5', u'8186||6', u'8187||1', u'8188||2', u'8190||2', u'8191||1']
Assistance greatly appreciated.
Thx
You could also split the strings on the || and specify the first part as the key parameter
sorted_d = sorted(d, key = lambda x: int(x.split('||')[0]))
print sorted_d
[u'399||1', u'412||1', u'412||2', u'413||1', u'414||1', u'434||2', u'616||1', u'617||1', u'618||1', u'619||1', u'620||1', u'621||1', u'622||1', u'727||1', u'1053||1', u'1092||2', u'1093||1', u'1094||1', u'1094||2', u'1095||1', u'1095||2', u'1096||7', u'1096||8', u'1097||7', u'1097||8', u'8096||1', u'8097||1', u'8099||1', u'8101||1', u'8105||1', u'8112||1', u'8113||1', u'8140||1', u'8141||1', u'8142||1', u'8143||1', u'8144||1', u'8146||2', u'8150||1', u'8152||1', u'8153||1', u'8154||1', u'8157||1', u'8158||1', u'8159||1', u'8160||1', u'8161||1', u'8162||1', u'8163||1', u'8164||1', u'8165||1', u'8166||1', u'8167||1', u'8168||1', u'8169||1', u'8170||1', u'8171||1', u'8172||1', u'8173||1', u'8174||1', u'8175||1', u'8184||2', u'8184||3', u'8185||2', u'8185||3', u'8186||5', u'8186||6', u'8187||1', u'8188||2', u'8190||2', u'8191||1', u'11064||1', u'11064||2']
Because it's treating your '1053||1' data as strings and sorting as a string type instead of as a numeric value. So it effectively is sorting in this type of manner, ascending:
1
10
100
1000
2
20
200
2000
Now I am making the leveldb to train caffe framework.So I use "convert_imageset.cpp". This cpp file writes the char-type data only to leveldb.
But I have the float data to write it to leveldb. This data is pre-proceed image data so it is float type data.
how can I write or convert this float data to leveldb.
This float data is a set of vector with 4096 dimensions.
Please help me.
Or not how to convert it to HDF5Data?
HDF5 stands for hierarchical data format. You can manipulate such data format for example with R (RHDF5 documentation)
Other software that can process HDF5 are Matlab and Mathematica.
EDIT
A new set of tools called HDFql has been recently released to simplify "managing HDF files through a high-level language like C/C++". You can check it out here
def del_and_create(dname):
if os.path.exists(dname):
shutil.rmtree(dname)
os.makedirs(dname)
def get_img_datum(image_fn):
img = cv.imread(image_fn, cv.IMREAD_COLOR)
img = img.swapaxes(0, 2).swapaxes(1, 2)
datum = caffe.io.array_to_datum(img, 0)
return datum
def get_jnt_datum(joint_fn):
joint = np.load(joint_fn)
datum = caffe.io.caffe_pb2.Datum()
datum.channels = len(joint)
datum.height = 1
datum.width = 1
datum.float_data.extend(joint.tolist())
return datum
def create_dataset():
img_db_fn = 'img.lmdb'
del_and_create(img_db_fn)
img_env = lmdb.Environment(img_db_fn, map_size=1099511627776)
img_txn = img_env.begin(write=True, buffers=True)
jnt_db_fn = 'joint.lmdb'
del_and_create(jnt_db_fn)
jnt_env = lmdb.Environment(jnt_db_fn, map_size=1099511627776)
jnt_txn = jnt_env.begin(write=True, buffers=True)
img_fns = glob.glob('imageData/*.jpg')
fileCount = len(img_fns)
print 'A total of ', fileCount, ' images.'
jnt_fns = glob.glob('jointData/*.npy')
jointCount = len(jnt_fns)
if(fileCount != jointCount):
print 'The file counts doesnot match'
exit()
keys = np.arange(fileCount)
np.random.shuffle(keys)
for i, (img_fn, jnt_fn) in enumerate( zip(sorted(img_fns), sorted(jnt_fns)) ):
img_datum = get_img_datum(img_fn)
jnt_datum = get_jnt_datum(jnt_fn)
key = '%010d' % keys[i]
img_txn.put(key, img_datum.SerializeToString())
jnt_txn.put(key, jnt_datum.SerializeToString())
if i % 10000 == 0:
img_txn.commit()
jnt_txn.commit()
jnt_txn = jnt_env.begin(write=True, buffers=True)
img_txn = img_env.begin(write=True, buffers=True)
print '%d'%(i), os.path.basename(img_fn), os.path.basename(jnt_fn)
img_txn.commit()
jnt_txn.commit()
img_env.close()
jnt_env.close()
The above code expects images from a given path, and the labels of each image as .npy file.
Credits: https://github.com/mitmul/deeppose/blob/caffe/scripts/dataset.py
Note: I had seen Shai's answer to a question, which claims that lmdb doesnot support float-type data. But, it does work for me with the latest version of Caffe and LMDB and using this code snippet. As his answer is way too old, its highly likely that older versions may not have supported float-type data.
I would like to ask for help.
Please for help me with my code in Python 2.7. I want plotting concentration of gas release.
Two weeks ago I started with Python, I did not see it before, I have basic knowledge with Pascal, but it is different language.
I do not know why does not work...
This picture showing how it must look like:
flickr.com/photos/95370861#N02/8696658905/in/photostream/lightbox/
My code:
from __future__ import division
from matplotlib.patches import Polygon, Rectangle
import math
import numpy as np
import matplotlib.pyplot as plt
def draw(x, y,ax, color, lw=1):
xr, yr = np.copy(x)[::-1], np.copy(y)[::-1]
for i in range(len(y)):
y[i] = -y[i]
verts = zip(x.tolist() + xr.tolist(), y.tolist() + yr.tolist())
poly = Polygon(verts, facecolor=color, edgecolor='k', lw=lw)
ax.add_patch(poly)
def concentration_chart_plume(x,y, ax, ticks, colors, title):
maxX = 0
for tick, color in zip(ticks[::-1], colors):
x, y = calculation(tick)
draw(np.array(x), np.array(y), ax, color)
maxX = max([maxX] + x)
''' plot parameters '''
plt.xlim(0, maxX)
plt.axis('equal')
plt.xlabel('$x[m]$')
plt.ylabel('$y[m]$')
plt.title(title)
sqrs = [Rectangle((0, 0), 1, 1, fc=clr) for clr in colors[::-1]]
desc = ["> %g" % tick for tick in ticks]
plt.legend(sqrs, desc, title="Concentration $kg/m^3$")
plt.grid()
def calculation(tick,m):
cx = FILE_1
sy = FILE_2
x = FILE_3
y = [sy * np.sqrt(2 * np.log(cx / (tick)))] #I do not know, how can be limited to non-zero values
return (x, y)
if __name__ == "__main__":
''' Concentration plot of continuous gas release '''
title = u"conturs"
colors = ["#9EFF00", "#FFF500", "#FF9900", "#FF2E00"]
ticks = [0.1, 1e-2, 1e-3, 1e-4] # value of concentration kg/m3, I want to show up
fig = plt.figure()
ax = fig.gca()
plt.show()
FILE_1 values:
[ 2.21000000e+00 2.19000000e+00 2.16000000e+00 2.12000000e+00
2.08000000e+00 1.90000000e+00 1.71000000e+00 1.18000000e+00
7.93000000e-01 3.55000000e-01 1.93000000e-01 7.02500000e-02
3.70800000e-02 1.37100000e-02 7.42100000e-03 4.77800000e-03
3.39200000e-03 2.56200000e-03 2.02100000e-03 1.64600000e-03
1.37300000e-03 1.16800000e-03 1.00900000e-03 8.82300000e-04
7.80300000e-04 6.96400000e-04 6.26500000e-04 5.67500000e-04
5.17200000e-04 4.73800000e-04 4.36200000e-04 4.03200000e-04
3.74200000e-04 3.48500000e-04 3.25600000e-04 3.05100000e-04
2.86700000e-04 2.70000000e-04 2.54900000e-04 2.28500000e-04
2.17000000e-04 1.96700000e-04 1.87700000e-04 1.71600000e-04
1.64300000e-04 1.51300000e-04 1.45500000e-04 1.34800000e-04
1.29900000e-04 1.21100000e-04 1.17000000e-04 1.09500000e-04
1.06000000e-04 9.96600000e-05 9.67000000e-05 9.12100000e-05
8.86500000e-05 8.38800000e-05 8.16600000e-05 7.74900000e-05
7.55300000e-05 7.18600000e-05 7.01300000e-05 6.68800000e-05
6.53500000e-05 6.38700000e-05 6.24500000e-05 6.10800000e-05
5.97600000e-05 5.84800000e-05 5.72600000e-05 5.60700000e-05
5.49200000e-05 5.38100000e-05 5.27400000e-05 5.17100000e-05
5.07000000e-05 4.97300000e-05 4.92400000e-05 4.72200000e-05
4.35700000e-05 4.19100000e-05 3.88600000e-05 3.74700000e-05
3.49000000e-05 3.37200000e-05 3.15400000e-05 3.05300000e-05
2.86500000e-05 2.77800000e-05 2.61500000e-05 2.54000000e-05
2.39800000e-05 2.33200000e-05 2.20700000e-05 2.14900000e-05
2.03900000e-05 1.98700000e-05 1.89000000e-05 1.84300000e-05
1.75600000e-05 1.71500000e-05 1.63700000e-05 1.60000000e-05
1.53000000e-05 1.49700000e-05 1.43300000e-05 1.40300000e-05
1.34600000e-05 1.31800000e-05 1.26600000e-05 1.24100000e-05
1.19400000e-05 1.17100000e-05 1.12700000e-05 1.10600000e-05
1.06600000e-05 1.04700000e-05 1.01000000e-05 9.92500000e-06
9.58500000e-06 9.42200000e-06 9.10900000e-06 8.81100000e-06]
and FILE_2 values:
[ 9.21500000e-07 1.68000000e-01 3.13000000e-01 4.47000000e-01
5.58000000e-01 8.37000000e-01 1.08000000e+00 1.67000000e+00
2.20000000e+00 3.31000000e+00 4.30000000e+00 6.53000000e+00
8.50000000e+00 1.29000000e+01 1.68000000e+01 2.03000000e+01
2.37000000e+01 2.68000000e+01 2.98000000e+01 3.27000000e+01
3.55000000e+01 3.82000000e+01 4.08000000e+01 4.34000000e+01
4.59000000e+01 4.83000000e+01 5.07000000e+01 5.31000000e+01
5.54000000e+01 5.77000000e+01 5.99000000e+01 6.21000000e+01
6.43000000e+01 6.65000000e+01 6.86000000e+01 7.07000000e+01
7.28000000e+01 7.49000000e+01 7.69000000e+01 8.09000000e+01
8.29000000e+01 8.68000000e+01 8.87000000e+01 9.25000000e+01
9.44000000e+01 9.81000000e+01 9.99000000e+01 1.04000000e+02
1.05000000e+02 1.09000000e+02 1.11000000e+02 1.14000000e+02
1.16000000e+02 1.19000000e+02 1.21000000e+02 1.24000000e+02
1.26000000e+02 1.29000000e+02 1.31000000e+02 1.34000000e+02
1.36000000e+02 1.39000000e+02 1.41000000e+02 1.44000000e+02
1.46000000e+02 1.47000000e+02 1.49000000e+02 1.50000000e+02
1.52000000e+02 1.53000000e+02 1.55000000e+02 1.57000000e+02
1.58000000e+02 1.60000000e+02 1.61000000e+02 1.63000000e+02
1.64000000e+02 1.66000000e+02 1.66000000e+02 1.69000000e+02
1.73000000e+02 1.75000000e+02 1.80000000e+02 1.82000000e+02
1.87000000e+02 1.89000000e+02 1.93000000e+02 1.96000000e+02
2.00000000e+02 2.02000000e+02 2.07000000e+02 2.09000000e+02
2.13000000e+02 2.15000000e+02 2.20000000e+02 2.22000000e+02
2.26000000e+02 2.28000000e+02 2.33000000e+02 2.35000000e+02
2.39000000e+02 2.41000000e+02 2.46000000e+02 2.48000000e+02
2.52000000e+02 2.54000000e+02 2.59000000e+02 2.61000000e+02
2.65000000e+02 2.67000000e+02 2.72000000e+02 2.74000000e+02
2.78000000e+02 2.80000000e+02 2.84000000e+02 2.86000000e+02
2.91000000e+02 2.93000000e+02 2.97000000e+02 2.99000000e+02
3.03000000e+02 3.06000000e+02 3.10000000e+02 3.14000000e+02]
and FILE_3 values:
[ 2.59000000e+00 2.69000000e+00 2.92000000e+00 3.23000000e+00
3.54000000e+00 4.48000000e+00 5.41000000e+00 8.00000000e+00
1.06000000e+01 1.66000000e+01 2.27000000e+01 3.82000000e+01
5.37000000e+01 9.37000000e+01 1.34000000e+02 1.74000000e+02
2.14000000e+02 2.54000000e+02 2.94000000e+02 3.34000000e+02
3.74000000e+02 4.14000000e+02 4.54000000e+02 4.94000000e+02
5.34000000e+02 5.74000000e+02 6.14000000e+02 6.54000000e+02
6.94000000e+02 7.34000000e+02 7.74000000e+02 8.14000000e+02
8.54000000e+02 8.94000000e+02 9.34000000e+02 9.74000000e+02
1.01400000e+03 1.05400000e+03 1.09400000e+03 1.17400000e+03
1.21400000e+03 1.29400000e+03 1.33400000e+03 1.41400000e+03
1.45400000e+03 1.53400000e+03 1.57400000e+03 1.65400000e+03
1.69400000e+03 1.77400000e+03 1.81400000e+03 1.89400000e+03
1.93400000e+03 2.01400000e+03 2.05400000e+03 2.13400000e+03
2.17400000e+03 2.25400000e+03 2.29400000e+03 2.37400000e+03
2.41400000e+03 2.49400000e+03 2.53400000e+03 2.61400000e+03
2.65400000e+03 2.69400000e+03 2.73400000e+03 2.77400000e+03
2.81400000e+03 2.85400000e+03 2.89400000e+03 2.93400000e+03
2.97400000e+03 3.01400000e+03 3.05400000e+03 3.09400000e+03
3.13400000e+03 3.17400000e+03 3.19500000e+03 3.25500000e+03
3.37500000e+03 3.43500000e+03 3.55500000e+03 3.61500000e+03
3.73500000e+03 3.79500000e+03 3.91500000e+03 3.97500000e+03
4.09500000e+03 4.15500000e+03 4.27500000e+03 4.33500000e+03
4.45500000e+03 4.51500000e+03 4.63500000e+03 4.69500000e+03
4.81500000e+03 4.87500000e+03 4.99500000e+03 5.05500000e+03
5.17500000e+03 5.23500000e+03 5.35500000e+03 5.41500000e+03
5.53500000e+03 5.59500000e+03 5.71500000e+03 5.77500000e+03
5.89500000e+03 5.95500000e+03 6.07500000e+03 6.13500000e+03
6.25500000e+03 6.31500000e+03 6.43500000e+03 6.49500000e+03
6.61500000e+03 6.67500000e+03 6.79500000e+03 6.85500000e+03
6.97500000e+03 7.03500000e+03 7.15500000e+03 7.27500000e+03]
Thank you for your help
Prema
Step 1: Make sure you can actually see a simple plot.
You need to set up python so that the following script shows you something:
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0,2*np.pi)
y = np.sin(x)
plt.plot(x,y)
plt.show()
If this doesn't work, it's no surprise that you're not seeing anything with your more complicated plot. Getting this working depends on the details of your system, but a good place to start is by figuring out which backend you want to use.
For interactive use, most people who need to interact with plots frequently will just use ipython with pylab, started from the command line as
ipython --pylab
You may need to install ipython and pylab to get this working.
Step 1b: Save output figure?
Alternatively, if the interactive plot isn't working for you, or you just want to save the figure to a file, you can replace plt.show() with
plt.savefig('/path/to/file.png')
You can replace png with pdf or various other file types.
Step 2: Get your code working.
The code you've posted contains several errors, and no request to draw a plot. Here are some corrections I see. Your function definitions have too many variables; they should be
def concentration_chart_plume(ax, ticks, colors, title):
and
def calculation(tick):
Your equation should be something like
y = np.asarray(sy) * np.sqrt(2 * np.log(np.asarray(cx) / (tick)))
Python doesn't know how to multiply lists together, so you have to make them into numpy arrays. Also, you should insert as the second-to-last line of your code (right before plt.show()) the line
concentration_chart_plume(ax, ticks, colors, title)
which actually draws the plot.
Finally, I assume that you're doing something sensible so that your script gets the right values of FILE_1, FILE_2, and FILE_3.
Step 3: Check your equation
I don't know what you're trying to plot, but the equation you're using gives invalid values (as you seem to know) any time the element in cx is less than 1.0. Is this really the right equation? If so, you might want to use something like
cx = [max(1.0, c) for c in cx]
after you set the values of cx, but before you use them. Then, the logarithm will always be 0.0 or greater, so that the square-root exists. This basically throws away smaller values of your data, so I'm assuming that they're just noise or something....
Step N+1: Enjoy the results
After making all of the changes listed in steps 2 and 3 (and correcting the spelling of the title), I get the following very-reasonable-looking plot: