def makePlanCached (xstart, xend, N, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbose=True, foldername='../Cases/cachedPlans', cachname='plan.plan', verbosePlan=False):
descrfilename = 'description.csv'
descrfilepath = foldername+'/'+descrfilename
filename =foldername+'/'+cachname #os.path.basename(__file__).replace('.py','_plan')
try:
oplan=o_p.readPlanFromFile(filename) #переключение на чтение априорного плана из файла
print ("Read file successful")
except BaseException as e:
oplan=grandApriornPlanning (xstart, xend, N, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbose=True, verbosePlan=verbosePlan)[1]
o_p.writePlanToFile(oplan, filename)
# работаем с csv-базой планов
with open(descrfilepath, 'a+') as dfile:
#mine: при открытии файла а+ читальный курсор перемещается в конец файла, надо его вернуть
dfile.seek(0) #иначе и при заполненном csv он будет выдавать пустой файл
if dfile.read()=='': #если считываем пустую строку в начале файла
dfile.write ('xstart, xend, N, bstart, bend, c, Ve, cachname \n') #то пишем туда заголовки
dfile.write(','.join([str(x) for x in [xstart, xend, N, bstart, bend, c, Ve, cachname]] )) #и информацию
dfile.write('\n')
return oplan
def test():
"""
Тестирует последовательное планирование
:return:
"""
xstart=[1, 100]
xend=[20,200]
c={"a":1000}
funcf=lambda x,b,c: np.array ( [ b[0]+b[1]*x[0]+b[2]*x[1]+b[3]*x[0]*x[1]+b[4]*x[0]*x[0]+b[5]*x[1]*x[1], b[6]+b[7]*x[0]+b[8]*x[1]+b[9]*x[0]*x[1]+b[10]*x[0]*x[0]+b[11]*x[1]*x[1] ] )
jacf = lambda x,b,c,y: np.matrix([ [1, x[0], x[1], x[0]*x[1], x[0]*x[0], x[1]*x[1], 0, 0, 0, 0, 0, 0],
[0,0,0,0,0,0,1,x[0], x[1], x[0]*x[1], x[0]*x[0], x[1]*x[1]] ])
Ve=np.array([ [0.0001, 0],
[0, 0.0001]] )
btrue=[8,4,2,2,9,3,4,2,2,3,4,5]
bstart=np.array(btrue)-np.array([2]*len(btrue))
bend=np.array(btrue)+np.array([2]*len(btrue))
binit=[1]*len(btrue)
N=32
#seqplanb=getbSeqPlanUltra (xstart, xend, N, btrue, binit, c, Ve, jacf, funcf, initplan=o_p.makeRandomUniformExpPlan(xstart, xend, 5), dotlim=500)
print("performing aprior plan:")
oplan=o_ap.grandApriornPlanning (xstart, xend, N, bstart, bend, c, Ve, jacf, func=None, Ntries=5)[1]
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve )
gknu=o_e.grandCountGN_UltraX1(funcf, jacf, measdata, binit, c, NSIG=10, implicit=False, verbose=False) #получили оценку b binit=bs
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c)
print("\n\nperforming sequence plan with uniform as seed:")
seqplanb=o_sp.getbSeqPlanUltra(xstart, xend, N, btrue, binit, c, Ve, jacf, funcf, initplan=o_p.makeUniformExpPlan(xstart, xend, 4), dotlim=200, NSIG=10)
measdata = o_p.makeMeasAccToPlan(funcf, seqplanb[3], btrue, c,Ve)
gknu=o_e.grandCountGN_UltraX1(funcf, jacf, measdata, binit, c, NSIG=10, implicit=False, verbose=False) #получили оценку b binit=bs
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c)
o_q.printSeqPlanData(seqplanb)
#И самый огонь - последовательный план с априорным в затравке!
print("\n\nperforming sequence plan with aprior as seed (hybrid):")
seqplanb=o_sp.getbSeqPlanUltra(xstart, xend, N, btrue, binit, c, Ve, jacf, funcf, initplan=oplan, dotlim=200, NSIG=10)
#seqplanb=o_sp.getHybridPlan(xstart, xend, N, btrue, binit, bstart, bend, c, Ve, jacf, funcf)
measdata = o_p.makeMeasAccToPlan(funcf, seqplanb[3], btrue, c,Ve)
gknu=o_e.grandCountGN_UltraX1(funcf, jacf, measdata, binit, c, NSIG=10, implicit=False, verbose=False) #получили оценку b binit=bs
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c)
o_q.printSeqPlanData(seqplanb)
def testEstimate():
"""
Пробуем произвести экстракцию параметров модели по параметрам транзистора Эрли
:return:
"""
jacf=lambda x,b,c,y: outTransParamFormatJAC (x,b)
funcf=lambda x,b,c: outTransParamFormat (x,b)
c={}
Ve=np.array([ [0.000001, 0],
[0, 0.000001] ] )
#BF,BR,IS
#коэфф передачи по току в схеме с оэ нормальный режим, -//- реверсный, ток утечки
btrue=[120,1,1.28]
binit=[110,2,1.28]
bstart=[100,0.5,1]
bend=[125,2,2]
xstart=[0.001,0.001]
xend=[5,5]
N=50
print("performing normal research:")
startplan = o_p.makeUniformExpPlan(xstart, xend, N)
measdata = o_p.makeMeasAccToPlan(funcf, startplan, btrue, c, Ve)
#надо добавить скажем априорный план, с фильтрованием точек
print ('Plan optimization: measdatalen={0} optimized={1}'.format(len(measdata), len(list(filter(for_filter, measdata)) )))
measdata = list(filter(for_filter, measdata))
gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=10)
print (gknu)
print (o_q.getQualitat(measdata, gknu[0], Ve, funcf, c))
print (gknu[0])
return
# aprior plan
print("Performing aprior plan:")
oplan = o_ap.grandApriornPlanning(xstart, xend, 10, bstart, bend, c, Ve, jacf, Ntries=2)
o_p.writePlanToFile(oplan, 'Aprior_plan')
measdata = o_p.makeMeasAccToPlan(funcf, oplan, btrue, c, Ve)
filteredmeasdata=list(filter(for_filter, measdata))
print ('Plan optimization: measdatalen={0} optimized={1}'.format(len(measdata), len(filteredmeasdata) ))
gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=10)
print (gknu)
print (o_q.getQualitat(measdata, gknu[0], Ve, funcf, c))
def testNew():
funstr = [
"y[0]+y[1]-y[2]", "y[0]*b[0]-y[1]*b[1]-x[0]-x[1]",
"y[1]*b[1]+y[2]*b[2]+x[1]"
]
updfunstr = list(map(lambda x: x.replace('[', '').replace(']', ''),
funstr))
dfdy = lambda y, x, b, c: np.array([[1, 1, -1], [b[0], -b[1], 0],
[0, b[1], b[2]]])
dfdb = lambda y, x, b, c: np.array([[0, 0, 0], [y[0], -y[1], 0],
[0, y[1], y[2]]])
#возвращает функцию
function = lambda y, x, b, c: [
y[0] + y[1] - y[2], y[0] * b[0] - y[1] * b[1] - x[0] - x[1], y[1] * b[
1] + y[2] * b[2] + x[1]
]
#возвращает структурную матрицу
#jacf=lambda x,b,c,y: jjacf(x,b,c,y,dfdb,dfdy)
jacf = lambda x, b, c, y: np.dot(np.linalg.inv(dfdy(y, x, b, c)),
dfdb(y, x, b, c))
#возвращает значение y
funcf = lambda x, b, c: optimize.root(
function, [1, 1, 1], args=(x, b, c), method='lm', jac=dfdy).x
#теперь попробуем сделать эксперимент.
c = {}
Ve = np.array([[0.0001, 0, 0], [0, 0.0001, 0], [0, 0, 0.0001]])
btrue = [60, 60, 40]
bstart = np.array(btrue) - np.array([2] * len(btrue))
bend = np.array(btrue) + np.array([2] * len(btrue))
binit = [60, 55, 45]
xstart = [10, 40]
#xend=[20,60]
xend = [210, 340]
N = 30
print("performing normal research:")
startplan = o_p.makeUniformExpPlan(xstart, xend, N)
measdata = o_p.makeMeasAccToPlan(funcf, startplan, btrue, c, Ve)
gknu = o_e.grandCountGN_UltraX1(funcf,
jacf,
measdata,
binit,
c,
NSIG=6,
sign=0)
print(gknu)
print(o_q.getQualitat(measdata, gknu[0], Ve, funcf, c))
def extraction_Kirch_DiodeV2Mod2DirectBranch():
"""
[Реестровая]
:return:
"""
global FT
global foldername
funcf=solver_Kirch_DiodeV2Mod2DirectBranch
jacf = Jac_Kirch_DiodeV2Mod2DirectBranch
c={}
Ve=np.array([ [1e-5] ] )
# 0 1 2 3 4 5 6
btrue=[1.238e-14, 1.8, 1.123e-14, 1.5, 1.12, 0.5, 123.]
bstart=np.array(btrue)-np.array(btrue)*0.3
bend=np.array(btrue)+np.array(btrue)*0.3
#binit=[1.1e-14, 1.5, 1.1e-14, 1.9, 1.0, 0.8, 100.]
binit = np.array(btrue)-np.array(btrue)*0.1
xstart=[0.001]
xend=[1.5]
N=40 #число точек в плане (для планов, кроме априорного)
NArprior=20 #число точек в априорном плане
#Получаем априорный план
import os
filename =foldername+'/'+os.path.basename(__file__).replace('.py','N{0}_plan'.format (NArprior))
try:
oplan=o_p.readPlanFromFile(filename) #переключение на чтение априорного плана из файла
print ("Read file successful")
except BaseException as e:
oplan=o_ap.grandApriornPlanning (xstart, xend, NArprior, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbose=True)[1]
o_p.writePlanToFile(oplan, filename)
newxstart=1.4
oplan = [item for item in oplan if item[0]<newxstart]
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve )
gknuxlim = o_el.grandCountGN_UltraX1_Limited_wrapper(funcf,jacf,measdata,binit,bstart,bend, c, implicit=True, verbose=False, verbose_wrapper=True )
#gknux = o_e.grandCountGN_UltraX1(funcf, jacf, measdata, binit, c, implicit=True)
gknuxlim2=o_q.convertToQualitatStandart (gknuxlim, funcf, jacf, measdata, c, Ve, name='Limited Count Aprior')
#gknux2=o_q.convertToQualitatStandart (gknux, funcf, jacf, measdata, c, Ve, name='Normal Count Aprior')
o_q.printQualitatStandart (gknuxlim2)
def testDiodeParameterExtractionIMPLICIT():
"""
пробуем экстрагировать коэффициенты из модели диода
коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
входные параметры: напряжение, приложенное источником к системе резистор-диод
+-----------|||||---------->|--------- -
Резистор подключен до диода
:return:
"""
#возвращает значение y
funcf = diodeResistorIMPLICITfunction
jacf = diodeResistorIMPLICITJac
#теперь попробуем сделать эксперимент.
c = {}
Ve = np.array([[0.000000001]])
btrue = [1.238e-14, 1.8, 50]
bstart = np.array(btrue) - np.array(btrue) * 0.2
bend = np.array(btrue) + np.array(btrue) * 0.2
binit = [1.e-10, 1.1, 1]
xstart = [0.01]
#xend=[20,60]
xend = [1.1]
N = 50
print("performing normal research:")
global numnone
numnone = 0
startplan = o_p.makeUniformExpPlan(xstart, xend, N)
measdata = o_p.makeMeasAccToPlan(funcf, startplan, btrue, c, Ve)
print('unsuccessful estimations: ', numnone, 'Проверка отключена')
gknu = o_empm.grandCountGN_UltraX1_mpmath(funcf,
jacf,
measdata,
binit,
c,
NSIG=6,
sign=0)
#как мы помним, в случае неявных функций должно ставить sign=0
print(gknu[0])
def countMeanVbForAprior_S4000(expplan:list, bstart:list, bend:list, c, Ve, jac, func=None):
"""
:param expplan: план эксперимента
:param bstart: начало диапазона b (вектор)
:param bend: конец диапазона b (вектор)
:param c: словарь доп. параметров
:param Ve: ковариационная матрица ошибок экспериментов
:param jac: функция якобиана (на входе x,b,c=None, y=None)
:return: среднее значение определителя [0] и его дисперсию [1]
"""
DS=0 #среднее определителя
SD=0 #дисперсия определителя
for sss in range(1, 30): #30 - количество попыток в выборке
b=o_g.uniformVector (bstart, bend)
Vb=o_p.countVbForPlan(expplan, b, c, Ve, jac, func)
D=np.linalg.det(Vb)
if D:
DS=(D+(sss-1)*DS)/sss #среднее определителя
SD=((DS-D)*(DS-D)+(sss-1)*SD)/sss #дисперсия определителя
return DS, SD
def testNew():
funstr= ["y[0]+y[1]-y[2]", "y[0]*b[0]-y[1]*b[1]-x[0]-x[1]", "y[1]*b[1]+y[2]*b[2]+x[1]"]
updfunstr=list(map(lambda x: x.replace('[','').replace(']',''), funstr))
dfdy=lambda y,x,b,c: np.array( [ [1, 1, -1],
[b[0], -b[1], 0],
[0, b[1], b[2]]
])
dfdb=lambda y,x,b,c: np.array ([[ 0, 0, 0 ],
[y[0],-y[1], 0 ],
[0, y[1], y[2] ] ])
#возвращает функцию
function=lambda y,x,b,c: [y[0]+y[1]-y[2], y[0]*b[0]-y[1]*b[1]-x[0]-x[1], y[1]*b[1]+y[2]*b[2]+x[1]]
#возвращает структурную матрицу
#jacf=lambda x,b,c,y: jjacf(x,b,c,y,dfdb,dfdy)
jacf=lambda x,b,c,y:np.dot(np.linalg.inv(dfdy(y,x,b,c)), dfdb(y,x,b,c))
#возвращает значение y
funcf=lambda x,b,c: optimize.root(function, [1, 1, 1], args=(x,b,c),method='lm', jac=dfdy).x
#теперь попробуем сделать эксперимент.
c={}
Ve=np.array([ [0.0001, 0, 0],
[0, 0.0001, 0],
[0, 0, 0.0001] ] )
btrue=[60,60,40]
bstart=np.array(btrue)-np.array([2]*len(btrue))
bend=np.array(btrue)+np.array([2]*len(btrue))
binit=[60,55,45]
xstart=[10,40]
#xend=[20,60]
xend=[210,340]
N=30
print("performing normal research:")
startplan = o_p.makeUniformExpPlan(xstart, xend, N)
measdata = o_p.makeMeasAccToPlan(funcf, startplan, btrue, c, Ve)
gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=6, sign=0)
print (gknu)
print (o_q.getQualitat(measdata, gknu[0], Ve, funcf, c))
def extraction_Kirch_DiodeV2Mod2DirectBranchMpmath():
"""
[Реестровая]
:return:
"""
global FT,XO,XT,XF
global foldername
funcf=solver_Kirch_DiodeV2Mod2DirectBranchMpmath
jacf = Jac_Kirch_DiodeV2Mod2DirectBranchMpmath
c=None
Ve=np.array([ [1e-5] ] )
# 0 1 2 3 4 5 6
btrue=[mpm.mpf('341.4e-6'), mpm.mpf('2.664'), mpm.mpf('37.08e-3'), mpm.mpf('17.26e-27'), mpm.mpf('5.662'), mpm.mpf('4.282'), mpm.mpf('0.5751'), mpm.mpf('3.65e-3')]
#коридор в 20 процентов в обе стороны
diap = mpm.mpf('.2')
bstart = [item-item*diap for item in btrue]
bend = [item+item*diap for item in btrue]
binit=btrue
xstart=[mpm.mpf('0.001')]
xend=[mpm.mpf('1.5')]
N=20
print("performing aprior plan:")
#примитивная попытка автоматизировать, риальни надо кешировать в файл под хешем параметров
import os
filename =foldername+'/'+'_'.format(N)+os.path.basename(__file__).replace('.py','_plan')
try:
oplan=o_p.readPlanFromFile(filename) #переключение на чтение априорного плана из файла
print ("Read file successful")
except BaseException as e:
oplan=o_ap.grandApriornPlanning (xstart, xend, N, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbose=True)[1]
o_p.writePlanToFile(oplan, filename)
def test():
"""
Тестирует априорное планирование
:return:
"""
xstart = [1, 100]
xend = [20, 200]
N = 10
c = {"a": 1000}
funcf = lambda x, b, c: np.array([
b[1] + b[2] * x[1] + b[3] * x[2] + b[4] * x[1] * x[2] + b[5] * x[1] *
x[1] + b[6] * x[2] * x[2], b[7] + b[8] * x[1] + b[9] * x[2] + b[
10] * x[1] * x[2] + b[11] * x[1] * x[1] + b[12] * x[2] * x[2]
])
jacf = lambda x, b, c, y: np.matrix([[
1, x[0], x[1], x[0] * x[1], x[0] * x[0], x[1] * x[1], 0, 0, 0, 0, 0, 0
], [
0, 0, 0, 0, 0, 0, 1, x[0], x[1], x[0] * x[1], x[0] * x[0], x[1] * x[1]
]])
#убрал .T
Ve = np.array([[0.1, 0], [0, 0.1]])
bstart = [0.8, 0.4, 1.4, 0.2, 0.9, 0.3, 1.4, 0.2, 2.1, 3.1, 4.1, 5.1]
blen = [0.3, 0.2, 0.2, 0.2, 0.2, 0.3, 0.2, 0.2]
bend = [1.1, 0.6, 1.6, 0.4, 1.1, 0.6, 1.6, 0.4, 2.5, 3.3, 4.6, 5.6]
#print (doublesearch ([1, 0.5], [10,10], [9,9], lambda x: x[0]*x[0]+2*x[1]*x[1]+10)) #тестирование поиска
rs = o_ap.grandApriornPlanning(xstart,
xend,
N,
bstart,
bend,
c,
Ve,
jacf,
func=None,
Ntries=1)
print(rs[0])
print('Experimental plan')
for r in rs[1]:
print(r[0], '\t', r[1])
print(rs[1])
measdata = o_p.makeMeasAccToPlan(funcf, rs, bend, c, Ve)
#надо добавить скажем априорный план, с фильтрованием точек
gknu = o_e.grandCountGN_UltraX1(funcf, jacf, measdata, bstart, c, NSIG=10)
print(gknu)
print(o_q.getQualitat(measdata, gknu[0], Ve, funcf, c))
print(gknu[0])
def testDiodeParameterExtractionIMPLICIT():
"""
пробуем экстрагировать коэффициенты из модели диода
коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
входные параметры: напряжение, приложенное источником к системе резистор-диод
+-----------|||||---------->|--------- -
Резистор подключен до диода
:return:
"""
# возвращает значение y
funcf = diodeResistorIMPLICITfunction
jacf = diodeResistorIMPLICITJac
# теперь попробуем сделать эксперимент.
c = {}
Ve = np.array([[0.000000001]])
btrue = [1.238e-14, 1.8, 50]
bstart = np.array(btrue) - np.array(btrue) * 0.2
bend = np.array(btrue) + np.array(btrue) * 0.2
binit = [1.0e-10, 1.1, 1]
xstart = [0.01]
# xend=[20,60]
xend = [1.1]
N = 50
print("performing normal research:")
global numnone
numnone = 0
startplan = o_p.makeUniformExpPlan(xstart, xend, N)
measdata = o_p.makeMeasAccToPlan(funcf, startplan, btrue, c, Ve)
print("unsuccessful estimations: ", numnone, "Проверка отключена")
gknu = o_empm.grandCountGN_UltraX1_mpmath(funcf, jacf, measdata, binit, c, NSIG=6, sign=0)
# как мы помним, в случае неявных функций должно ставить sign=0
print(gknu[0])
def testSimpleFunction ():
#проходит, 2 итерации, если b=b+deltab*mu
funcstrdict= {"y1":"u1* (r2+r3)", "y2":"u1* r3"}
xstart=[1, 100]
xend=[20,200]
N=50
funcf=lambda x,b,c=None: [x[1]*x[0]*(b[0]+b[1]), x[0]*b[1]+x[1]*b[0]]
jacf = lambda x,b,c=None,y=None: np.array([[x[0]*x[1],x[0]*x[1]],[x[1], x[0]]])
Ve=np.array([ [0.00001, 0],
[0, 0.00001]] )
btrue= [20,30]
binit=[1]*len(btrue)
print("performing normal research:")
startplan = o_p.makeUniformExpPlan(xstart, xend, N)
measdata = o_p.makeMeasAccToPlan(funcf, startplan, btrue, None, Ve)
gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, None,NSIG=10)
print (gknu)
print (o_q.getQualitat(measdata, gknu[0], Ve, funcf, None))
print (gknu[0])
def makeplan_lambda (plantype, n, bstart, bend, Ve):
global xstart, xend, btrue,c
#- делает нужный план в зависимости от параметров plantype и n
#Надо создать пачку априорных планов - 5 10 15 20 25 30 35 40 значений
hash= hashlib.md5((n,bstart,bend,Ve).__str__().encode('utf-8')).hexdigest()
#hashlib.md5("whatever your string is".encode('utf-8')).
filename = usercomment+'_'+str(hash)
if plantype: #если априорный
return o_ap.makePlanCached (xstart, xend, n, bstart, bend, c, Ve, jacf, funcf, Ntries=4, verbose=False, foldername='DependencyPlans', cachname=filename)
else:
return o_p.makeUniformExpPlan(xstart,xend,n)
def test():
"""
Тестирует априорное планирование
:return:
"""
xstart=[1, 100]
xend=[20,200]
N=10
c={"a":1000}
funcf=lambda x,b,c: np.array ( [ b[1]+b[2]*x[1]+b[3]*x[2]+b[4]*x[1]*x[2]+b[5]*x[1]*x[1]+b[6]*x[2]*x[2], b[7]+b[8]*x[1]+b[9]*x[2]+b[10]*x[1]*x[2]+b[11]*x[1]*x[1]+b[12]*x[2]*x[2] ] )
jacf = lambda x,b,c,y: np.matrix([ [1, x[0], x[1], x[0]*x[1], x[0]*x[0], x[1]*x[1], 0, 0, 0, 0, 0, 0],
[0,0,0,0,0,0,1,x[0], x[1], x[0]*x[1], x[0]*x[0], x[1]*x[1]] ])
#убрал .T
Ve=np.array([ [0.1, 0],
[0, 0.1]] )
bstart=[0.8,0.4,1.4,0.2,0.9,0.3,1.4,0.2,2.1,3.1,4.1,5.1]
blen= [0.3,0.2,0.2,0.2,0.2,0.3,0.2,0.2]
bend= [1.1,0.6,1.6,0.4,1.1,0.6,1.6,0.4,2.5,3.3,4.6,5.6]
#print (doublesearch ([1, 0.5], [10,10], [9,9], lambda x: x[0]*x[0]+2*x[1]*x[1]+10)) #тестирование поиска
rs=o_ap.grandApriornPlanning (xstart, xend, N, bstart, bend, c, Ve, jacf, func=None, Ntries=1)
print (rs[0])
print ('Experimental plan')
for r in rs[1]:
print(r[0], '\t', r[1])
print(rs[1])
measdata = o_p.makeMeasAccToPlan(funcf, rs, bend, c, Ve)
#надо добавить скажем априорный план, с фильтрованием точек
gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, bstart, c,NSIG=10)
print (gknu)
print (o_q.getQualitat(measdata, gknu[0], Ve, funcf, c))
print (gknu[0])
def gknuxfunc_lambda (plan, binit, bstart, bend, Ve):
"""
:param plan:
:param binit:
:param bstart:
:param bend:
:param Ve:
:return:
"""
global btrue, c, xstart, xend, funcf, jacf
try:
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, plan, btrue, c,Ve )
except:
return None
gknuxlim = o_el.grandCountGN_UltraX1_Limited_wrapper(funcf,jacf,measdata,binit,bstart,bend, c, implicit=True, verbose=False, verbose_wrapper=False )
try:
gknuxlim2=o_q.convertToQualitatStandart (gknuxlim, funcf, jacf, measdata, c, Ve, name='Limited Count Aprior Dependency')
except:
return None
return gknuxlim2
def testSquareFunction():
#проходит за 9 итераций b=b+deltab*mu
xstart=[1, 100]
xend=[20,200]
N=10
c={"a":1000}
funcf=lambda x,b,c=None: [ b[0]+b[1]*x[0]+b[2]*x[1]+b[3]*x[0]*x[1]+b[4]*x[0]**2+b[5]*x[1]**2, b[6]+b[7]*x[0]+b[8]*x[1]+b[9]*x[0]*x[1]+b[10]*x[0]**2+b[11]*x[1]**2 ]
jacf = lambda x,b,c=None,y=None: np.array([ [1, x[0], x[1], x[0]*x[1], x[0]*x[0], x[1]*x[1], 0, 0, 0, 0, 0, 0],
[0,0,0,0,0,0,1,x[0], x[1], x[0]*x[1], x[0]*x[0], x[1]*x[1]] ])
#убрал .T
Ve=np.array([ [0.0001, 0],
[0, 0.0001]] )
bstart=[0.8,0.4,1.4,0.2,0.9,0.3,1.4,0.2,2.1,3.1,4.1,5.1]
btrue= [1.1,0.6,1.6,0.4,1.1,0.6,1.6,0.4,2.5,3.3,4.6,5.6]
bend=list(np.array(btrue)+np.array(btrue)-np.array(bstart))
binit=[1]*len(btrue)
N=50
# print("performing normal research:")
# startplan = o_p.makeUniformExpPlan(xstart, xend, N)
# measdata = o_p.makeMeasAccToPlan(funcf, startplan, btrue, c, Ve)
# gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c,NSIG=10)
# print (gknu)
# print (o_q.getQualitat(measdata, gknu[0], Ve, funcf, c))
# print (gknu[0])
print("performing aprior research:")
oplan = o_ap.grandApriornPlanning (xstart, xend, 10, bstart, bend, c, Ve, jacf, func=None, Ntries=1)[1]
print(oplan)
measdata = o_p.makeMeasAccToPlan(funcf, oplan, btrue, c, Ve)
gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c,NSIG=10)
print (gknu)
print (o_q.getQualitat(measdata, gknu[0], Ve, funcf, c))
print (gknu[0])
def extraction_Diode_Irev_Limited():
"""
пробуем экстрагировать коэффициенты из модели диода
коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
входные параметры: напряжение, приложенное источником к системе резистор-диод
+-----------|||||---------->|--------- -
Резистор подключен до диода
:return:
"""
global FT
global foldername
#возвращает значение y
funcf = solver_Diode_Irev_Limited
jacf = jac_Diode_Irev_Limited
#теперь попробуем сделать эксперимент.
c = {}
Ve = np.array([[1.34e-7]
]) #согласно погрешности на мультиметре CHROMA 12061
#btrue=[5.31656e-8,2 ,.0392384] #номинальные значения диода D1N4001
btrue = [
5e-8, 400, .0422
] #номинальные значения диода D1N4001 с сайта, вроде официальной модели производителя
# V=x[0] #напряжение на диоде, в данном случае обратное
# IBV=b[0]
# BV=b[1]
# R=b[2]
bstart = np.array(btrue) - np.array(btrue) * 0.1
bend = np.array(btrue) + np.array(btrue) * 0.1
print('conditions:')
print(bstart)
print(bend)
binit = [
5e-8, 400, .0422
] #номинальные значения диода D1N4001 с сайта, вроде официальной модели производителя
xstart = [399]
xend = [401]
N = 30
print("performing uniform plan:")
plan = o_p.makeUniformExpPlan(xstart, xend, N)
measdata = o_p.makeMeasAccToPlan(funcf, plan, btrue, c, None)
print(measdata)
plotPlanAndMeas2D(measdata)
exit(0)
print("performing aprior plan:")
#примитивная попытка автоматизировать, риальни надо кешировать в файл под хешем параметров
import os
filename = foldername + '/' + 'RD_11N4004_' + os.path.basename(
__file__).replace('.py', '_plan')
try:
oplan = o_p.readPlanFromFile(
filename) #переключение на чтение априорного плана из файла
print("Read file successful")
except BaseException as e:
oplan = o_ap.grandApriornPlanning(xstart,
xend,
N,
bstart,
bend,
c,
Ve,
jacf,
funcf,
Ntries=6,
verbose=True)[1]
o_p.writePlanToFile(oplan, filename)
# получаем измеренные данные
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c, Ve)
# #чертим эти данные
# #o_pl.plotPlanAndMeas2D(measdata, 'Aprior Disp{0} measdata'.format(Ve))
#
# #оценка
#grandCountGN_UltraX1_Limited_wrapper (funcf, jacf, measdata:list, binit:list, bstart:list, bend:list, c, A, NSIG=50, NSIGGENERAL=50, implicit=False, verbose=False, verbose_wrapper=False):
gknuxlim = o_el.grandCountGN_UltraX1_Limited_wrapper(funcf,
jacf,
measdata,
binit,
bstart,
bend,
c,
implicit=True,
verbose=False,
verbose_wrapper=False)
gknux = o_e.grandCountGN_UltraX1(funcf,
jacf,
measdata,
binit,
c,
implicit=True)
gknuxlim2 = o_q.convertToQualitatStandart(gknuxlim,
funcf,
jacf,
measdata,
c,
Ve,
name='Limited Count Aprior')
gknux2 = o_q.convertToQualitatStandart(gknux,
funcf,
jacf,
measdata,
c,
Ve,
name='Normal Count Aprior')
o_q.printQualitatStandart(gknuxlim2)
o_q.printQualitatStandart(gknux2)
def extraction_Diode_Irev_Limited():
"""
пробуем экстрагировать коэффициенты из модели диода
коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
входные параметры: напряжение, приложенное источником к системе резистор-диод
+-----------|||||---------->|--------- -
Резистор подключен до диода
:return:
"""
global FT
global foldername
#возвращает значение y
funcf=solver_Diode_Irev_Limited
jacf = jac_Diode_Irev_Limited
#теперь попробуем сделать эксперимент.
c={}
Ve=np.array([ [1.34e-7] ] ) #согласно погрешности на мультиметре CHROMA 12061
#btrue=[5.31656e-8,2 ,.0392384] #номинальные значения диода D1N4001
btrue=[5e-8, 400 ,.0422] #номинальные значения диода D1N4001 с сайта, вроде официальной модели производителя
# V=x[0] #напряжение на диоде, в данном случае обратное
# IBV=b[0]
# BV=b[1]
# R=b[2]
bstart=np.array(btrue)-np.array(btrue)*0.1
bend=np.array(btrue)+np.array(btrue)*0.1
print('conditions:')
print(bstart)
print(bend)
binit=[5e-8, 400 ,.0422] #номинальные значения диода D1N4001 с сайта, вроде официальной модели производителя
xstart=[399]
xend=[401]
N=30
print("performing uniform plan:")
plan = o_p.makeUniformExpPlan(xstart,xend, N)
measdata = o_p.makeMeasAccToPlan(funcf, plan, btrue, c,None )
print (measdata)
plotPlanAndMeas2D(measdata)
exit(0)
print("performing aprior plan:")
#примитивная попытка автоматизировать, риальни надо кешировать в файл под хешем параметров
import os
filename =foldername+'/'+'RD_11N4004_'+os.path.basename(__file__).replace('.py','_plan')
try:
oplan=o_p.readPlanFromFile(filename) #переключение на чтение априорного плана из файла
print ("Read file successful")
except BaseException as e:
oplan=o_ap.grandApriornPlanning (xstart, xend, N, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbose=True)[1]
o_p.writePlanToFile(oplan, filename)
# получаем измеренные данные
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve )
# #чертим эти данные
# #o_pl.plotPlanAndMeas2D(measdata, 'Aprior Disp{0} measdata'.format(Ve))
#
# #оценка
#grandCountGN_UltraX1_Limited_wrapper (funcf, jacf, measdata:list, binit:list, bstart:list, bend:list, c, A, NSIG=50, NSIGGENERAL=50, implicit=False, verbose=False, verbose_wrapper=False):
gknuxlim = o_el.grandCountGN_UltraX1_Limited_wrapper(funcf,jacf,measdata,binit,bstart,bend, c, implicit=True, verbose=False, verbose_wrapper=False )
gknux = o_e.grandCountGN_UltraX1(funcf, jacf, measdata, binit, c, implicit=True)
gknuxlim2=o_q.convertToQualitatStandart (gknuxlim, funcf, jacf, measdata, c, Ve, name='Limited Count Aprior')
gknux2=o_q.convertToQualitatStandart (gknux, funcf, jacf, measdata, c, Ve, name='Normal Count Aprior')
o_q.printQualitatStandart (gknuxlim2)
o_q.printQualitatStandart (gknux2)
def extraction_Kirch_DiodeV2Mod2DirectBranch():
"""
[Реестровая]
:return:
"""
global FT
global foldername
funcf = solver_Kirch_DiodeV2Mod2DirectBranch
jacf = Jac_Kirch_DiodeV2Mod2DirectBranch
c = {}
Ve = np.array([[1e-5]])
# 0 1 2 3 4 5 6
btrue = [1.238e-14, 1.8, 1.123e-14, 1.5, 1.12, 0.5, 123.]
bstart = np.array(btrue) - np.array(btrue) * 0.3
bend = np.array(btrue) + np.array(btrue) * 0.3
#binit=[1.1e-14, 1.5, 1.1e-14, 1.9, 1.0, 0.8, 100.]
binit = np.array(btrue) - np.array(btrue) * 0.1
xstart = [0.001]
xend = [1.5]
N = 40 #число точек в плане (для планов, кроме априорного)
NArprior = 20 #число точек в априорном плане
#Получаем априорный план
import os
filename = foldername + '/' + os.path.basename(__file__).replace(
'.py', 'N{0}_plan'.format(NArprior))
try:
oplan = o_p.readPlanFromFile(
filename) #переключение на чтение априорного плана из файла
print("Read file successful")
except BaseException as e:
oplan = o_ap.grandApriornPlanning(xstart,
xend,
NArprior,
bstart,
bend,
c,
Ve,
jacf,
funcf,
Ntries=6,
verbose=True)[1]
o_p.writePlanToFile(oplan, filename)
newxstart = 1.4
oplan = [item for item in oplan if item[0] < newxstart]
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c, Ve)
gknuxlim = o_el.grandCountGN_UltraX1_Limited_wrapper(funcf,
jacf,
measdata,
binit,
bstart,
bend,
c,
implicit=True,
verbose=False,
verbose_wrapper=True)
#gknux = o_e.grandCountGN_UltraX1(funcf, jacf, measdata, binit, c, implicit=True)
gknuxlim2 = o_q.convertToQualitatStandart(gknuxlim,
funcf,
jacf,
measdata,
c,
Ve,
name='Limited Count Aprior')
#gknux2=o_q.convertToQualitatStandart (gknux, funcf, jacf, measdata, c, Ve, name='Normal Count Aprior')
o_q.printQualitatStandart(gknuxlim2)
def testDiodeParameterExtractionIMPLICIT(plot=True):
"""
пробуем экстрагировать коэффициенты из модели диода
коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
входные параметры: напряжение, приложенное источником к системе резистор-диод
+-----------|||||---------->|--------- -
Резистор подключен до диода
:return:
"""
#возвращает значение y
funcf = diodeResistorIMPLICITfunction
jacf = diodeResistorIMPLICITJac
#теперь попробуем сделать эксперимент.
c = {}
Ve = np.array([[0.00000001]])
btrue = [1.238e-14, 1.8, 100]
#btrue=[1.5e-14, 1.75, 150]
bstart = np.array(btrue) - np.array(btrue) * 0.3
bend = np.array(btrue) + np.array(btrue) * 0.3
binit = [1.0e-14, 1.7, 70]
#binit=[1.238e-14, 1.8, 100]
xstart = [0.001]
#xend=[20,60]
xend = [2]
N = 20
print("performing aprior plan:")
#примитивная попытка автоматизировать, риальни надо кешировать в файл под хешем параметров
try:
oplan = o_p.readPlanFromFile(
) #переключение на чтение априорного плана из файла
print("Read file successful")
except BaseException as e:
oplan = o_ap.grandApriornPlanning(xstart,
xend,
N,
bstart,
bend,
c,
Ve,
jacf,
funcf,
Ntries=6,
verbosePlan=True,
verbose=True)[1]
o_p.writePlanToFile(oplan)
#получаем измеренные данные
# measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve )
# #чертим эти данные
# #o_pl.plotPlanAndMeas2D(measdata, 'Aprior Disp{0} measdata'.format(Ve))
#
# #оценка
# gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=100, implicit=True)
#
# #вывод данных оценки - данные, квалитат, дроп
# o_q.printGKNUNeat(gknu)
# o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c)
# if plot:
# o_pl.plotSkGraph(gknu, 'Aprior Research Sk drop')
#
#
terminationOptDict = {'VdShelfPow': -7}
#
#
# N=30
#
# print("\n\nperforming sequence plan with random as seed:")
# seqplanb=o_sp.getbSeqPlanUltra(xstart, xend, N, btrue, binit, c, Ve, jacf, funcf, dotlim=100, verbose=False, NSIG=100, implicit=True, lognorm=True, terminationOptDict=terminationOptDict) #создаём последовательный план, с выводом инфо по итерациям
# #выводим данные последовательного планирования
# o_q.printSeqPlanData(seqplanb)
# #получаем данные измерения по этому последовательному плану
# measdata = o_p.makeMeasAccToPlan_lognorm(funcf, seqplanb[3], btrue, c,Ve)
# #чертим эти данные
# if plot:
# o_pl.plotPlanAndMeas2D(measdata, 'Hybrid Disp{0} measdata'.format(Ve))
# print("GKNU for plan")
# gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=100, implicit=True)
# o_q.printGKNUNeat(gknu)
# o_q.printQualitatNeat(measdataETALON, gknu[0], Ve, funcf, c)
# if plot:
# o_pl.plotSkGraph(gknu, 'Hybrid bei plan Sk drop')
#
#
#
# print("\n\nperforming sequence plan with uniform as seed:")
# unifplan=o_p.makeUniformExpPlan(xstart, xend, N)
# seqplanb=o_sp.getbSeqPlanUltra(xstart, xend, N, btrue, binit, c, Ve, jacf, funcf, initplan=unifplan, dotlim=100, verbose=False, NSIG=100, implicit=True, lognorm=True, terminationOptDict=terminationOptDict) #создаём последовательный план, с выводом инфо по итерациям
# #выводим данные последовательного планирования
# o_q.printSeqPlanData(seqplanb)
# #получаем данные измерения по этому последовательному плану
# measdata = o_p.makeMeasAccToPlan_lognorm(funcf, seqplanb[3], btrue, c,Ve)
# #чертим эти данные
# if plot:
# o_pl.plotPlanAndMeas2D(measdata, 'Hybrid Disp{0} measdata'.format(Ve))
# print("GKNU for plan")
# gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=100, implicit=True)
# o_q.printGKNUNeat(gknu)
# o_q.printQualitatNeat(measdataETALON, gknu[0], Ve, funcf, c)
# if plot:
# o_pl.plotSkGraph(gknu, 'Hybrid bei plan Sk drop')
#
#
# print("\n\nperforming sequence plan with aprior as seed (hybrid):")
# seqplanb=o_sp.getbSeqPlanUltra(xstart, xend, N, btrue, binit, c, Ve, jacf, funcf, dotlim=100, verbose=False, NSIG=100, implicit=True, lognorm=True, terminationOptDict=terminationOptDict) #создаём последовательный план, с выводом инфо по итерациям
# # #выводим данные последовательного планирования
# o_q.printSeqPlanData(seqplanb)
#получаем данные измерения по этому последовательному плану
# #пробуем несколько измерений произвести
# resarr=list()
# #несколько раз измерения
# t=PrettyTable (['Среднее логарифма правдоподобия','Сигма логарифма правдоподобия' , 'b','Среднее остатков по модулю'])
# for i in range(20):
# measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve)
# gknu=o_e.grandCountGN_UltraX_ExtraStart (funcf, jacf, measdata, bstart, bend, c, Ve, NSIG=100, implicit=True, verbose=False, Ntries=10, name='aprior plan plus several measurements')
# if (gknu):
# resarr.append(gknu)
# if resarr:
# for gknu in resarr:
# if (gknu):
# t.add_row([gknu['AvLogTruth'],gknu['SigmaLT'], gknu['b'], gknu['AvDif'] ])
# be=o_e.selectBestEstim (resarr)
# t.add_row(['*', '*', '*', '*' ])
# t.add_row([be['AvLogTruth'], be['SigmaLT'], be['b'], be['AvDif'] ])
# print(t)
# o_q.analyseDifList(be)
#Априорный план просто
startplan = o_p.makeUniformExpPlan(xstart, xend, 150)
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, startplan, btrue, c, Ve)
gknu = o_e.grandCountGN_UltraX1(funcf,
jacf,
measdata,
binit,
c,
NSIG=100,
implicit=True)
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c, jacf)
def extraction_Kirch_DiodeV2Mod2DirectBranch():
"""
[Реестровая]
:return:
"""
global FT
global foldername
funcf = solver_Kirch_DiodeV2Mod2DirectBranch
jacf = Jac_Kirch_DiodeV2Mod2DirectBranch
c = {}
Ve = np.array([[1.9e-5]])
btrue = [341.4e-6, 2.664, 37.08e-3, 17.26e-27, 5.662, 4.282, 0.5751, 3.65e-3]
bstart = np.array(btrue) - np.array(btrue) * 0.05
bend = np.array(btrue) + np.array(btrue) * 0.05
binit = [
341.4e-6,
2.664,
37.08e-3,
17.26e-27,
5.662,
4.282,
0.5751,
3.65e-3,
] # binit=btrue так как взято из спайс-модели
xstart = [0.7]
# xend=[20,60]
xend = [0.77]
N = 20 # число точек в априорном плане
# Получаем априорный план
print("performing aprior plan:")
# блок кеширования априорного плана в файл
import os
filename = (
foldername + "/" + "RD_10BQ100_N{0}_Dev-62012P_".format(N) + os.path.basename(__file__).replace(".py", "_plan")
)
try:
oplan = o_p.readPlanFromFile(filename) # переключение на чтение априорного плана из файла
print("Read file successful")
except BaseException as e:
oplan = o_ap.grandApriornPlanning(xstart, xend, N, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbose=True)[1]
o_p.writePlanToFile(oplan, filename)
# #Задание опций для последовательного плана
# terminationOptDict={'VdShelfPow':-7}
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c, Ve)
plotPlanAndMeas2D(measdata)
gknuxlim = o_el.grandCountGN_UltraX1_Limited_wrapper(
funcf, jacf, measdata, binit, bstart, bend, c, implicit=True, verbose=False, verbose_wrapper=False
)
gknuxlim2 = o_q.convertToQualitatStandart(gknuxlim, funcf, jacf, measdata, c, Ve, name="Limited Count Aprior")
o_q.printQualitatStandart(gknuxlim2)
def grandApriornPlanning (xstart:list, xend:list, N:int, bstart:list, bend:list, c, Ve, jac, func=None, Ntries=30, verbosePlan=False, initplan=None, verbose=False):
"""
Реализует априорное планирование эксперимента
:param xstart: начало диапазона x (вектор)
:param xend: конец диапазона x (вектор)
:param N: размер плана (количество контрольных точек)
:param bstart: начало диапазона b (вектор)
:param bend: конец диапазона b (вектор)
:param c: словарь дополнительных переменных
:param Ve: Ковариационная матрица y, реально её диагональ (вектор)
:param jac: Якобиан функции, принимает на вход x,b,c,y
:param verbosePlan: если true, пишет все планы в файлы, иначе только оптимальный
:param initplan: начальный план. По умолчанию случаен, но может быть задан (в этом случае делается одна попытка)
:param verbose: выдавать ли в консоль информацию optimized-original
:return: кортеж: 0: оптимизированное значение определителя Vb, 1: оптимальный план эксперимента
"""
#Апдейт: теперь по умолчанию в список планов заряжается равномерный
dopt=100000000
planopt=None
Ntries1=Ntries+1
if initplan!=None:
Ntries1=1
if verbose:
print('\n\nДанные априорного планирования:')
print('Неоптимизированное-оптимизированное значение среднего det(Vb)')
prevtime=time.time()
for i in range(0,Ntries1):
try:
if initplan==None:
m=len(xstart) #длина вектора входных параметров
plan = o_p.makeUniformExpPlan(xstart, xend, N**(1/float(m))) if i==0 else o_p.makeRandomUniformExpPlan(xstart, xend, N)
if verbose:
print('plan length:', len(plan))
else:
plan = initplan
unopt=countMeanVbForAprior_S4000(plan, bstart, bend, c, Ve, jac, func)[0]
#оптимизация
for j in range(N):
xdot=copy.deepcopy(plan[j])
function = lambda x: countMeanVbForAprior_S4000(o_g.replaceInList(plan,j,x), bstart, bend, c, Ve, jac, func)[0]
boundsarr=list()
for k in range(len(xstart)):
boundsarr.append((xstart[k],xend[k]))
#sol = optimize.minimize (function, xdot, bounds=boundsarr)
#plan[j]=sol.x
#В этом варианте не работает, хоть результат и проходит быстрее
plan[j]=o_g.doublesearch(xstart, xend, xdot, function)
dcurr=countMeanVbForAprior_S4000(plan, bstart, bend, c, Ve, jac, func)[0]
if verbose:
curtime = time.time() #in seconds
#st = datetime.datetime.fromtimestamp(curtime-prevtime).strftime('%Y-%m-%d %H:%M:%S')
st = datetime.datetime.fromtimestamp(curtime-prevtime).strftime('%H:%M:%S')
print ("{0} unoptimized-optimized: {1} {2} time spent: {3}".format('uniform' if i==0 else '',unopt, dcurr, st))
prevtime=copy.copy(curtime)
if dcurr<dopt or planopt==None:
dopt=dcurr
planopt=plan
if (verbosePlan):
o_p.writePlanToFile(plan, "{0}plan.txt".format(i))
except BaseException as e:
print ('This try failed, due to exception e=',e)
tb = traceback.format_exc()
print(tb)
return dopt, planopt
def testDiodeParameterExtractionIMPLICIT(plot=True):
"""
пробуем экстрагировать коэффициенты из модели диода
коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
входные параметры: напряжение, приложенное источником к системе резистор-диод
+-----------|||||---------->|--------- -
Резистор подключен до диода
:return:
"""
#возвращает значение y
funcf=diodeResistorIMPLICITfunction
jacf = diodeResistorIMPLICITJac
#теперь попробуем сделать эксперимент.
c={}
Ve=np.array([ [0.00000001] ] )
btrue=[1.238e-14, 1.8, 100]
#btrue=[1.5e-14, 1.75, 150]
bstart=np.array(btrue)-np.array(btrue)*0.3
bend=np.array(btrue)+np.array(btrue)*0.3
binit=[1.0e-14, 1.7, 70]
#binit=[1.238e-14, 1.8, 100]
xstart=[0.001]
#xend=[20,60]
xend=[2 ]
N=20
print("performing aprior plan:")
#примитивная попытка автоматизировать, риальни надо кешировать в файл под хешем параметров
try:
oplan=o_p.readPlanFromFile() #переключение на чтение априорного плана из файла
print ("Read file successful")
except BaseException as e:
oplan=o_ap.grandApriornPlanning (xstart, xend, N, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbosePlan=True, verbose=True)[1]
o_p.writePlanToFile(oplan)
#получаем измеренные данные
# measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve )
# #чертим эти данные
# #o_pl.plotPlanAndMeas2D(measdata, 'Aprior Disp{0} measdata'.format(Ve))
#
# #оценка
# gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=100, implicit=True)
#
# #вывод данных оценки - данные, квалитат, дроп
# o_q.printGKNUNeat(gknu)
# o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c)
# if plot:
# o_pl.plotSkGraph(gknu, 'Aprior Research Sk drop')
#
#
terminationOptDict={'VdShelfPow':-7}
#
#
# N=30
#
# print("\n\nperforming sequence plan with random as seed:")
# seqplanb=o_sp.getbSeqPlanUltra(xstart, xend, N, btrue, binit, c, Ve, jacf, funcf, dotlim=100, verbose=False, NSIG=100, implicit=True, lognorm=True, terminationOptDict=terminationOptDict) #создаём последовательный план, с выводом инфо по итерациям
# #выводим данные последовательного планирования
# o_q.printSeqPlanData(seqplanb)
# #получаем данные измерения по этому последовательному плану
# measdata = o_p.makeMeasAccToPlan_lognorm(funcf, seqplanb[3], btrue, c,Ve)
# #чертим эти данные
# if plot:
# o_pl.plotPlanAndMeas2D(measdata, 'Hybrid Disp{0} measdata'.format(Ve))
# print("GKNU for plan")
# gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=100, implicit=True)
# o_q.printGKNUNeat(gknu)
# o_q.printQualitatNeat(measdataETALON, gknu[0], Ve, funcf, c)
# if plot:
# o_pl.plotSkGraph(gknu, 'Hybrid bei plan Sk drop')
#
#
#
# print("\n\nperforming sequence plan with uniform as seed:")
# unifplan=o_p.makeUniformExpPlan(xstart, xend, N)
# seqplanb=o_sp.getbSeqPlanUltra(xstart, xend, N, btrue, binit, c, Ve, jacf, funcf, initplan=unifplan, dotlim=100, verbose=False, NSIG=100, implicit=True, lognorm=True, terminationOptDict=terminationOptDict) #создаём последовательный план, с выводом инфо по итерациям
# #выводим данные последовательного планирования
# o_q.printSeqPlanData(seqplanb)
# #получаем данные измерения по этому последовательному плану
# measdata = o_p.makeMeasAccToPlan_lognorm(funcf, seqplanb[3], btrue, c,Ve)
# #чертим эти данные
# if plot:
# o_pl.plotPlanAndMeas2D(measdata, 'Hybrid Disp{0} measdata'.format(Ve))
# print("GKNU for plan")
# gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=100, implicit=True)
# o_q.printGKNUNeat(gknu)
# o_q.printQualitatNeat(measdataETALON, gknu[0], Ve, funcf, c)
# if plot:
# o_pl.plotSkGraph(gknu, 'Hybrid bei plan Sk drop')
#
#
# print("\n\nperforming sequence plan with aprior as seed (hybrid):")
# seqplanb=o_sp.getbSeqPlanUltra(xstart, xend, N, btrue, binit, c, Ve, jacf, funcf, dotlim=100, verbose=False, NSIG=100, implicit=True, lognorm=True, terminationOptDict=terminationOptDict) #создаём последовательный план, с выводом инфо по итерациям
# # #выводим данные последовательного планирования
# o_q.printSeqPlanData(seqplanb)
#получаем данные измерения по этому последовательному плану
# #пробуем несколько измерений произвести
# resarr=list()
# #несколько раз измерения
# t=PrettyTable (['Среднее логарифма правдоподобия','Сигма логарифма правдоподобия' , 'b','Среднее остатков по модулю'])
# for i in range(20):
# measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve)
# gknu=o_e.grandCountGN_UltraX_ExtraStart (funcf, jacf, measdata, bstart, bend, c, Ve, NSIG=100, implicit=True, verbose=False, Ntries=10, name='aprior plan plus several measurements')
# if (gknu):
# resarr.append(gknu)
# if resarr:
# for gknu in resarr:
# if (gknu):
# t.add_row([gknu['AvLogTruth'],gknu['SigmaLT'], gknu['b'], gknu['AvDif'] ])
# be=o_e.selectBestEstim (resarr)
# t.add_row(['*', '*', '*', '*' ])
# t.add_row([be['AvLogTruth'], be['SigmaLT'], be['b'], be['AvDif'] ])
# print(t)
# o_q.analyseDifList(be)
#Априорный план просто
startplan = o_p.makeUniformExpPlan(xstart, xend, 150)
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, startplan, btrue, c,Ve)
gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=100, implicit=True)
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c, jacf)
def getbSeqPlanUltra(xstart: list,
xend: list,
N: int,
btrue: list,
binit: list,
c,
Ve,
jacf,
funcf,
initplan=None,
NSIG=10,
smallestdetVb=1e-6,
implicit=False,
lognorm=False,
dotlim=500,
verbose=False,
terminationOptDict={}):
"""
Осуществляет последовательное планирование и оценку коэффициентов модели
:param xstart: начало диапазона x
:param xend: конец диапазона x
:param N: количество точек в плане эксперимента
:param binit: стартовое значение вектора коэффициентов
:param btrue: истинное значение вектора коэффициентов
:param c: словарь дополнительных переменных
:param Ve: ковариационная матрица y
:param jacf: функция, возвращающая якобиан модели, входящие x,b,c,y
:param funcf: функция, возвращающая значение модели, входящие x,b,c
:param initplan: - начальный план
:param NSIG:
:param implicit - неявность функции. Если функция неявна, то в gknu sign=0
:param lognorm - требуется ли использование логнорм для получения измеренных данных
:param dotlim - предел добавленных точек
:param verbose - выводить ли информацию по итерациям
:param terminationOptDict - словарь опций завершения итеративного процесса:
VdShelfPow - по умолчанию -1 math.fabs(detVb-prevdetVb)/prevdetVb<math.pow(10,-VdShelfPow) NSIG для полки по detVb
:return: k, число итераций, лог
Для переделывания на реальные измерения btrue=None и функции моделирования переводятся на измерительные // btrue вообще должен бы быть исключен из всех функций ofiura
"""
startplan = initplan if initplan else o_p.makeRandomUniformExpPlan(
xstart, xend, N)
origplan = copy.copy(startplan)
measdata = o_p.makeMeasAccToPlan_lognorm(
funcf, startplan, btrue, c, Ve) if lognorm else o_p.makeMeasAccToPlan(
funcf, startplan, btrue, c, Ve)
log = ""
b = binit
prevdetVb = None
for numiter in range(
dotlim
): #ограничитель цикла - если выход произошёл по ограничению, значит, возможна ошибка
estim = o_e.grandCountGN_UltraX1(
funcf,
jacf,
measdata,
b,
c,
NSIG,
implicit=implicit,
verbose=False) #получили оценку b binit=b
#measdata почему-то разная, причины неизвестны.
b = estim[0]
Sk = estim[1]
Vb = o_p.countVbForMeasdata(b, c, Ve, jacf, measdata)
#посчитали определитель
detVb = np.linalg.det(Vb)
if verbose:
print(
"Sequence Plan Iteration: {0}\nb={1}\ndetVb={2}\nprevdetVb={3} \nSk={4}"
.format(numiter, b, detVb, prevdetVb, Sk))
VdShelfPow = terminationOptDict[
'VdShelfPow'] if 'VdShelfPow' in terminationOptDict else -1
condition = prevdetVb != None and math.fabs(
detVb - prevdetVb) / prevdetVb < math.pow(
10, VdShelfPow) #если вышли на плато
prevdetVb = detVb
if condition:
return b, numiter, Sk, startplan, origplan, log, estim, measdata, detVb #то всё вернуть
#иначе поиск следующей точки плана
xdot = copy.copy(
xstart
) #получили начальную точку начальное значение - ровно пополам диапазона
for i in range(len(xstart)): #присвоили ей значение
xdot[i] = xstart[i] + (xend[i] - xstart[i]) / 2
#объектная функция
measure = lambda x, b, c: o_p.makeMeasOneDot_lognorm(
funcf, x, b, c, Ve) if lognorm else o_p.makeMeasOneDot(
funcf, xdot, b, c, Ve)
function = lambda x: np.linalg.det(
o_p.countVbForPlan(o_g.appendToList(startplan, x), b, c, Ve, jacf,
measure))
#function = lambda x: np.linalg.det(o_p.countVbForPlan(o_g.appendToList(startplan, x),b,c,Ve,jacf, funcf))
#funcf заменено на measure, которая добавляет дисперсию.
#function и measure есть разные функции - первая даёт идеальный результат, вторая - с дисперсией
#создать функцию, которая будет возвращать полученные от func данные, налагая дисперсию.
#каждый раз будет пытаться добавить в план точку и вернуть определитель с добавленной точкой
#где тут добавлять дисперсию, а где - не добавлять, есть тащем-та вопрос открытый
xdot = o_g.doublesearch(xstart, xend, xdot,
function) #оптимизировали значение точки
startplan.append(xdot)
#measdata.append({'x':xdot, 'y':funcf(xdot,b,c)})
ymeas = o_p.makeMeasOneDot_lognorm(
funcf, xdot, btrue, c, Ve) if lognorm else o_p.makeMeasOneDot(
funcf, xdot, btrue, c, Ve)
#примитивная защита от кривых результатов измерения
if ymeas != None:
measdata.append({'x': xdot, 'y': ymeas})
#measdata = o_p.makeMeasAccToPlan_lognorm(funcf, startplan, btrue, c, Ve) if lognorm else o_p.makeMeasAccToPlan(funcf, startplan, btrue, c, Ve)
#окончание этого цикла "естественным путём" говорит о том, что превышено максимальное число итераций
return b, dotlim, Sk, startplan, origplan, log + "ERROR: maximum number of iterations archieved", estim, measdata, detVb
def getbSeqPlanUltra (xstart:list, xend:list, N:int, btrue:list, binit:list, c, Ve, jacf, funcf, initplan=None, NSIG=10, smallestdetVb=1e-6, implicit=False, lognorm=False, dotlim=100, verbose=False):
"""
Осуществляет последовательное планирование и оценку коэффициентов модели
:param xstart: начало диапазона x
:param xend: конец диапазона x
:param N: количество точек в плане эксперимента
:param binit: стартовое значение вектора коэффициентов
:param btrue: истинное значение вектора коэффициентов
:param c: словарь дополнительных переменных
:param Ve: ковариационная матрица y
:param jacf: функция, возвращающая якобиан модели, входящие x,b,c,y
:param funcf: функция, возвращающая значение модели, входящие x,b,c
:param initplan: - начальный план
:param NSIG:
:param implicit - неявность функции. Если функция неявна, то в gknu sign=0
:param lognorm - требуется ли использование логнорм для получения измеренных данных
:return: k, число итераций, лог
Для переделывания на реальные измерения btrue=None и функции моделирования переводятся на измерительные
"""
startplan = initplan if initplan else o_p.makeRandomUniformExpPlan(xstart, xend, N)
origplan = copy.copy(startplan)
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, startplan, btrue, c, Ve) if lognorm else o_p.makeMeasAccToPlan(funcf, startplan, btrue, c, Ve)
log=""
b=binit
prevdetVb=None
for numiter in range(dotlim): #ограничитель цикла - если выход произошёл по ограничению, значит, возможна ошибка
estim=o_e.grandCountGN_UltraX1(funcf, jacf, measdata, b, c, NSIG, implicit=implicit, verbose=False) #получили оценку b binit=b
#measdata почему-то разная, причины неизвестны.
b=estim[0]
Sk=estim[1]
Vb=o_p.countVbForMeasdata(b, c, Ve, jacf, measdata)
#посчитали определитель
detVb=np.linalg.det(Vb)
if verbose:
print ("Sequence Plan Iteration: {0}\nb={1}\ndetVb={2}\nprevdetVb={3} \nSk={4}".format(numiter, b, detVb, prevdetVb, Sk))
condition=prevdetVb!=None and math.fabs(detVb-prevdetVb)/prevdetVb<math.pow(10,-1) #если вышли на плато
prevdetVb=detVb
if condition:
return b, numiter, Sk, startplan, origplan, log, estim, measdata, detVb #то всё вернуть
#иначе поиск следующей точки плана
xdot=copy.copy(xstart) #получили начальную точку начальное значение - ровно пополам диапазона
for i in range(len(xstart)): #присвоили ей значение
xdot[i]=xstart[i]+(xend[i]-xstart[i])/2
#объектная функция
measure=lambda x,b,c:o_p.makeMeasOneDot_lognorm(funcf, x, b, c, Ve) if lognorm else o_p.makeMeasOneDot(funcf, xdot, b, c, Ve)
function = lambda x: np.linalg.det(o_p.countVbForPlan(o_g.appendToList(startplan, x),b,c,Ve,jacf, measure))
#funcf заменено на measure, которая добавляет дисперсию.
#function и measure есть разные функции - первая даёт идеальный результат, вторая - с дисперсией
#создать функцию, которая будет возвращать полученные от func данные, налагая дисперсию.
#каждый раз будет пытаться добавить в план точку и вернуть определитель с добавленной точкой
#где тут добавлять дисперсию, а где - не добавлять, есть тащем-та вопрос открытый
xdot=o_g.doublesearch (xstart, xend, xdot, function) #оптимизировали значение точки
startplan.append(xdot)
#measdata.append({'x':xdot, 'y':funcf(xdot,b,c)})
ymeas=o_p.makeMeasOneDot_lognorm(funcf, xdot, btrue, c, Ve) if lognorm else o_p.makeMeasOneDot(funcf, xdot, btrue, c, Ve)
measdata.append({'x':xdot, 'y':ymeas})
#measdata = o_p.makeMeasAccToPlan_lognorm(funcf, startplan, btrue, c, Ve) if lognorm else o_p.makeMeasAccToPlan(funcf, startplan, btrue, c, Ve)
#окончание этого цикла "естественным путём" говорит о том, что превышено максимальное число итераций
return b, dotlim, Sk, startplan, origplan, log+"ERROR: maximum number of iterations archieved", estim, measdata, detVb
def extraction_Kirch_DiodeV2Mod2DirectBranch():
"""
[Реестровая]
:return:
"""
funcf = func_Kirch_DiodeV2Mod2DirectBranch
jacf = Jac_Kirch_DiodeV2Mod2DirectBranch
c = {}
Ve = np.array([[0.0000000000001]])
btrue = [1.238e-14, 1.8, 1.5e-15, 1.9, 1.2, 0.5]
bstart = np.array(btrue) - np.array(btrue) * 0.1
bend = np.array(btrue) + np.array(btrue) * 0.1
binit = [1.238e-14, 1.7, 1.1e-20, 1.9, 1.1, 0.5]
xstart = [0.01]
#xend=[20,60]
xend = [1.5]
N = 200 #число точек в плане (для планов, кроме априорного)
NArprior = 30 #число точек в априорном плане
#Получаем априорный план
print("performing aprior plan:")
#блок кеширования априорного плана в файл
filename = os.path.basename(__file__).replace('.py', '_plan1')
try:
oplan = o_p.readPlanFromFile(
filename) #переключение на чтение априорного плана из файла
print("Read file successful")
except BaseException as e:
oplan = o_ap.grandApriornPlanning(xstart,
xend,
NArprior,
bstart,
bend,
c,
Ve,
jacf,
funcf,
Ntries=6,
verbosePlan=True,
verbose=True)[1]
o_p.writePlanToFile(oplan, filename)
#Задание опций для последовательного плана
terminationOptDict = {'VdShelfPow': -7}
#Оценивание параметров с использованием ряда начальных значений
# resarr=list() #Список результатов
# t=PrettyTable (['Среднее логарифма правдоподобия','Сигма логарифма правдоподобия' , 'b','Среднее остатков по модулю'])
# for i in range(30):
# measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve)
# gknu=o_e.grandCountGN_UltraX_ExtraStart (funcf, jacf, measdata, bstart, bend, c, Ve, NSIG=100, implicit=False, verbose=False, Ntries=10, name='aprior plan plus several measurements')
# if (gknu):
# resarr.append(gknu)
# if resarr:
# for gknu in resarr:
# if (gknu):
# t.add_row([gknu['AvLogTruth'],gknu['SigmaLT'], gknu['b'], gknu['AvDif'] ])
# be=o_e.selectBestEstim (resarr)
#
# t.add_row(['*', '*', '*', '*' ])
# t.add_row([be['AvLogTruth'], be['SigmaLT'], be['b'], be['AvDif'] ])
# print(t)
# #o_q.analyseDifList(be)
# o_q.printGKNUNeat(be)
# o_q.printQualitatNeat(measdata, be[0], Ve, funcf, c)
#Оценивание с использованием binit
# По априорному плану
# print('Aprior Plan Binit')
# #данные по новому формату
#
# measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve)
# gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=100, implicit=False)
# #o_q.analyseDifList(gknu)
# o_q.printGKNUNeat(gknu)
# o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c)
#
# #По нормальному плану
print("performing normal research:")
startplan = o_p.makeUniformExpPlan(xstart, xend, 150)
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, startplan, btrue, c, Ve)
gknu = o_e.grandCountGN_UltraX1(funcf,
jacf,
measdata,
binit,
c,
NSIG=100,
implicit=False)
if (gknu):
#o_q.analyseDifList(gknu)
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c, jacf)
def extraction_Diode_In_Limited():
"""
пробуем экстрагировать коэффициенты из модели диода
коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
входные параметры: напряжение, приложенное источником к системе резистор-диод
+-----------|||||---------->|--------- -
Резистор подключен до диода
:return:
"""
global FT
global foldername
#возвращает значение y
funcf=solver_Diode_In_Limited
jacf = jac_Diode_In_Limited
#теперь попробуем сделать эксперимент.
c={}
Ve=np.array([ [0.00000001] ] )
btrue=[1.238e-14, 1.8, 100]
#btrue=[1.5e-14, 1.75, 150]
bstart=np.array(btrue)-np.array(btrue)*0.3
bend=np.array(btrue)+np.array(btrue)*0.3002
#binit=np.array(btrue)-np.array(btrue)*0.1
print('conditions:')
print(bstart)
print(bend)
binit=[1.1e-14, 1.5, 90]
xstart=[0.001]
xend=[2]
N=20
print("performing aprior plan:")
#примитивная попытка автоматизировать, риальни надо кешировать в файл под хешем параметров
import os
filename =foldername+'/'+os.path.basename(__file__).replace('.py','_plan')
try:
oplan=o_p.readPlanFromFile(filename) #переключение на чтение априорного плана из файла
print ("Read file successful")
except BaseException as e:
oplan=o_ap.grandApriornPlanning (xstart, xend, N, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbose=True)[1]
o_p.writePlanToFile(oplan, filename)
# получаем измеренные данные
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve )
# #чертим эти данные
# #o_pl.plotPlanAndMeas2D(measdata, 'Aprior Disp{0} measdata'.format(Ve))
#
# #оценка
#grandCountGN_UltraX1_Limited_wrapper (funcf, jacf, measdata:list, binit:list, bstart:list, bend:list, c, A, NSIG=50, NSIGGENERAL=50, implicit=False, verbose=False, verbose_wrapper=False):
gknuxlim = o_el.grandCountGN_UltraX1_Limited_wrapper(funcf,jacf,measdata,binit,bstart,bend, c, implicit=True, verbose=False, verbose_wrapper=False )
gknux = o_e.grandCountGN_UltraX1(funcf, jacf, measdata, binit, c, implicit=True)
gknuxlim2=o_q.convertToQualitatStandart (gknuxlim, funcf, jacf, measdata, c, Ve, name='Limited Count Aprior')
gknux2=o_q.convertToQualitatStandart (gknux, funcf, jacf, measdata, c, Ve, name='Normal Count Aprior')
o_q.printQualitatStandart (gknuxlim2)
o_q.printQualitatStandart (gknux2)
#extraction_Diode_Irev_Limited()
def extraction_DiodeV4_partIn_Decimal(plot=True):
"""
пробуем экстрагировать коэффициенты из модели диода
коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
входные параметры: напряжение, приложенное источником к системе резистор-диод
+-----------|||||---------->|--------- -
Резистор подключен до диода
:return:
"""
#возвращает значение y
funcf = solver_DiodeV4_partIn_Decimal
jacf = jac_DiodeV4_partIn_Decimal
#теперь попробуем сделать эксперимент.
c = {}
Ve = np.array([[0.00000001]])
btrue = [1.238e-14, 1.8, 100]
#btrue=[1.5e-14, 1.75, 150]
bstart = np.array(btrue) - np.array(btrue) * 0.3
bend = np.array(btrue) + np.array(btrue) * 0.3
binit = [1.0e-14, 1.7, 70]
#binit=[1.238e-14, 1.8, 100]
xstart = [0.001]
#xend=[20,60]
xend = [1.5]
N = 100 #для неаприорных планов
NAprior = 20 #для априорных планов
#Получаем априорный план
print("performing aprior plan:")
#блок кеширования априорного плана в файл
filename = 'cachedPlans/' + os.path.basename(__file__).replace(
'.py', '_plan')
try:
oplan = o_p.readPlanFromFile(
filename) #переключение на чтение априорного плана из файла
print("Read file successful")
except BaseException as e:
oplan = o_ap.grandApriornPlanning(xstart,
xend,
NAprior,
bstart,
bend,
c,
Ve,
jacf,
funcf,
Ntries=6,
verbosePlan=True,
verbose=True)[1]
o_p.writePlanToFile(oplan, filename)
#}
unifplan = o_p.makeUniformExpPlan(xstart, xend, N)
#получаем измерения с планов
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c, Ve)
measdataUnif = o_p.makeMeasAccToPlan_lognorm(funcf, unifplan, btrue, c, Ve)
filename = os.path.basename(__file__).replace('.py', '_results')
#выполняем оценку
print("performing aprior plan")
gknu = o_e.grandCountGN_UltraX_Qualitat(funcf,
jacf,
measdata,
binit,
c,
Ve,
NSIG=100,
implicit=True)
o_q.analyseDifList(gknu, imagename='Aprior_Plan')
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)
print("performing uniform plan")
gknu = o_e.grandCountGN_UltraX_Qualitat(funcf,
jacf,
measdataUnif,
binit,
c,
Ve,
NSIG=100,
implicit=True)
o_q.analyseDifList(gknu, imagename='Uniform_Plan')
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)
def extraction_func_DiodeV3Approach1_part_In():
"""
[Реестровая]
:return:
"""
funcf = solver_func_DiodeV3Approach1_part_In
jacf = Jac_func_DiodeV3Approach1_part_In
c = {}
Ve = np.array([[0.001]])
btrue = [1.238e-14, 1.3]
bstart = np.array(btrue) - np.array(btrue) * 0.1
bend = np.array(btrue) + np.array(btrue) * 0.1
binit = np.array(btrue) + np.array(btrue) * 0.05
xstart = [0.01]
#xend=[20,60]
xend = [3]
N = 300 #число точек в плане (для планов, кроме априорного)
NArprior = 20 #число точек в априорном плане
#Получаем априорный план
print("performing aprior plan:")
#блок кеширования априорного плана в файл
filename = os.path.basename(__file__).replace('.py', '_plan')
try:
oplan = o_p.readPlanFromFile(
filename) #переключение на чтение априорного плана из файла
print("Read file successful")
except BaseException as e:
oplan = o_ap.grandApriornPlanning(xstart,
xend,
NArprior,
bstart,
bend,
c,
Ve,
jacf,
funcf,
Ntries=6,
verbosePlan=True,
verbose=True)[1]
o_p.writePlanToFile(oplan, filename)
#}
unifplan = o_p.makeUniformExpPlan(xstart, xend, N)
#получаем измерения с планов
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c, Ve)
measdataUnif = o_p.makeMeasAccToPlan_lognorm(funcf, unifplan, btrue, c, Ve)
filename = os.path.basename(__file__).replace('.py', '_results')
#выполняем оценку
print("performing aprior plan")
gknu = o_e.grandCountGN_UltraX_Qualitat(funcf,
jacf,
measdata,
binit,
c,
Ve,
NSIG=100,
implicit=True)
o_q.analyseDifList(gknu, imagename='Aprior_Plan')
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)
print("performing uniform plan")
gknu = o_e.grandCountGN_UltraX_Qualitat(funcf,
jacf,
measdataUnif,
binit,
c,
Ve,
NSIG=100,
implicit=True)
o_q.analyseDifList(gknu, imagename='Uniform_Plan')
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)
print("performing ExtraStart™ method")
resarr = list() #Список результатов
t = PrettyTable([
'Среднее логарифма правдоподобия', 'Сигма логарифма правдоподобия',
'b', 'Среднее остатков по модулю'
])
for i in range(30):
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c, Ve)
gknu = o_e.grandCountGN_UltraX_ExtraStart(
funcf,
jacf,
measdata,
bstart,
bend,
c,
Ve,
NSIG=100,
implicit=True,
verbose=False,
Ntries=10,
name='aprior plan plus several measurements')
if (gknu):
resarr.append(gknu)
if resarr:
for gknu in resarr:
if (gknu):
t.add_row([
gknu['AvLogTruth'], gknu['SigmaLT'], gknu['b'],
gknu['AvDif']
])
gknu = o_e.selectBestEstim(resarr)
t.add_row(['*', '*', '*', '*'])
t.add_row([gknu['AvLogTruth'], gknu['SigmaLT'], gknu['b'], gknu['AvDif']])
print(t)
o_q.analyseDifList(gknu, imagename='ExtraStart_et_Aprior_Plan')
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)
def testDiodeParameterExtraction():
"""
пробуем экстрагировать коэффициенты из модели диода
коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
входные параметры: напряжение, приложенное источником к системе резистор-диод
+-----------|||||---------->|--------- -
Резистор подключен до диода
:return:
"""
jacf=jacdiode
funcf=diode
#теперь попробуем сделать эксперимент.
c={}
Ve=np.asmatrix( [0.1] )
btrue=[1.238e-14, 1.8]
bstart=np.array(btrue)-np.array(btrue)*0.2
bend=np.array(btrue)+np.array(btrue)*0.2
binit=[1e-10,1.1]
xstart=[0.01]
xend=[2]
N=30
print("performing normal research:")
startplan = o_p.makeUniformExpPlan(xstart, xend, N)
print(len(startplan))
measdata = o_p.makeMeasAccToPlan(funcf, startplan, btrue, c, Ve)
planplot1=[x[0] for x in startplan]
measplot1=[x['y'][0] for x in measdata]
plt.plot(planplot1, measplot1, 'bo')
plt.show()
gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=6, sign=1)
#как мы помним, в случае неявных функций должно ставить sign=0
print (gknu[0])
print (o_q.getQualitat(measdata, gknu[0], Ve, funcf, c))
#plotting Sk graph
#TODO better organize: this code to estimation or somewhere
rng=np.arange(0,len(gknu[3]))
plt.plot(rng , gknu[3], label='Sk drop')
plt.legend(loc='upper left')
plt.ylabel('Sk')
plt.xlabel('Interation')
plt.grid()
plt.show()
N=20
print("performing aprior plan:")
oplan=o_ap.grandApriornPlanning (xstart, xend, N, bstart, bend, c, Ve, jacf, funcf, Ntries=6)[1]
o_p.writePlanToFile(oplan)
measdata = o_p.makeMeasAccToPlan(funcf, oplan, btrue, c,Ve )
planplot1=[x[0] for x in oplan]
measplot1=[x['y'][0] for x in measdata]
plt.plot(planplot1, measplot1, 'bo')
plt.show()
gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=6, sign=1)
print (gknu[0])
print (o_q.getQualitat(measdata, gknu[0], Ve, funcf, c))
#plotting Sk graph
#TODO better organize: this code to estimation or somewhere
rng=np.arange(0,len(gknu[3]))
plt.plot(rng , gknu[3], label='Sk drop')
plt.legend(loc='upper left')
plt.ylabel('Sk')
plt.xlabel('Interation')
plt.grid()
plt.show()
def extraction_Diode_In_Limited():
"""
пробуем экстрагировать коэффициенты из модели диода
коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
входные параметры: напряжение, приложенное источником к системе резистор-диод
+-----------|||||---------->|--------- -
Резистор подключен до диода
:return:
"""
global FT
global foldername
#возвращает значение y
funcf = solver_Diode_In_Limited
jacf = jac_Diode_In_Limited
#теперь попробуем сделать эксперимент.
c = {}
Ve = np.array([[0.00000001]])
btrue = [1.238e-14, 1.8, 100]
#btrue=[1.5e-14, 1.75, 150]
bstart = np.array(btrue) - np.array(btrue) * 0.3
bend = np.array(btrue) + np.array(btrue) * 0.3002
#binit=np.array(btrue)-np.array(btrue)*0.1
print('conditions:')
print(bstart)
print(bend)
binit = [1.1e-14, 1.5, 90]
xstart = [0.001]
xend = [2]
N = 20
print("performing aprior plan:")
#примитивная попытка автоматизировать, риальни надо кешировать в файл под хешем параметров
import os
filename = foldername + '/' + os.path.basename(__file__).replace(
'.py', '_plan')
try:
oplan = o_p.readPlanFromFile(
filename) #переключение на чтение априорного плана из файла
print("Read file successful")
except BaseException as e:
oplan = o_ap.grandApriornPlanning(xstart,
xend,
N,
bstart,
bend,
c,
Ve,
jacf,
funcf,
Ntries=6,
verbose=True)[1]
o_p.writePlanToFile(oplan, filename)
# получаем измеренные данные
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c, Ve)
# #чертим эти данные
# #o_pl.plotPlanAndMeas2D(measdata, 'Aprior Disp{0} measdata'.format(Ve))
#
# #оценка
#grandCountGN_UltraX1_Limited_wrapper (funcf, jacf, measdata:list, binit:list, bstart:list, bend:list, c, A, NSIG=50, NSIGGENERAL=50, implicit=False, verbose=False, verbose_wrapper=False):
gknuxlim = o_el.grandCountGN_UltraX1_Limited_wrapper(funcf,
jacf,
measdata,
binit,
bstart,
bend,
c,
implicit=True,
verbose=False,
verbose_wrapper=False)
gknux = o_e.grandCountGN_UltraX1(funcf,
jacf,
measdata,
binit,
c,
implicit=True)
gknuxlim2 = o_q.convertToQualitatStandart(gknuxlim,
funcf,
jacf,
measdata,
c,
Ve,
name='Limited Count Aprior')
gknux2 = o_q.convertToQualitatStandart(gknux,
funcf,
jacf,
measdata,
c,
Ve,
name='Normal Count Aprior')
o_q.printQualitatStandart(gknuxlim2)
o_q.printQualitatStandart(gknux2)
#extraction_Diode_Irev_Limited()
def extraction_func_DiodeV3Approach1_part_In():
"""
[Реестровая]
:return:
"""
funcf=solver_func_DiodeV3Approach1_part_In
jacf=Jac_func_DiodeV3Approach1_part_In
c={}
Ve=np.array([ [0.001] ] )
btrue=[1.238e-14, 1.3]
bstart=np.array(btrue)-np.array(btrue)*0.1
bend=np.array(btrue)+np.array(btrue)*0.1
binit=np.array(btrue)+np.array(btrue)*0.05
xstart=[0.01]
#xend=[20,60]
xend=[3]
N=300 #число точек в плане (для планов, кроме априорного)
NArprior=20 #число точек в априорном плане
#Получаем априорный план
print("performing aprior plan:")
#блок кеширования априорного плана в файл
filename = os.path.basename(__file__).replace('.py','_plan')
try:
oplan=o_p.readPlanFromFile(filename) #переключение на чтение априорного плана из файла
print ("Read file successful")
except BaseException as e:
oplan=o_ap.grandApriornPlanning (xstart, xend, NArprior, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbosePlan=True, verbose=True)[1]
o_p.writePlanToFile(oplan, filename)
#}
unifplan = o_p.makeUniformExpPlan(xstart, xend, N)
#получаем измерения с планов
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve )
measdataUnif = o_p.makeMeasAccToPlan_lognorm(funcf, unifplan, btrue, c,Ve )
filename = os.path.basename(__file__).replace('.py','_results')
#выполняем оценку
print ("performing aprior plan")
gknu=o_e.grandCountGN_UltraX_Qualitat (funcf, jacf, measdata, binit, c, Ve, NSIG=100, implicit=True)
o_q.analyseDifList(gknu, imagename='Aprior_Plan')
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)
print ("performing uniform plan")
gknu=o_e.grandCountGN_UltraX_Qualitat (funcf, jacf, measdataUnif, binit, c, Ve, NSIG=100, implicit=True)
o_q.analyseDifList(gknu, imagename='Uniform_Plan')
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)
print ("performing ExtraStart™ method")
resarr=list() #Список результатов
t=PrettyTable (['Среднее логарифма правдоподобия','Сигма логарифма правдоподобия' , 'b','Среднее остатков по модулю'])
for i in range(30):
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve)
gknu=o_e.grandCountGN_UltraX_ExtraStart (funcf, jacf, measdata, bstart, bend, c, Ve, NSIG=100, implicit=True, verbose=False, Ntries=10, name='aprior plan plus several measurements')
if (gknu):
resarr.append(gknu)
if resarr:
for gknu in resarr:
if (gknu):
t.add_row([gknu['AvLogTruth'],gknu['SigmaLT'], gknu['b'], gknu['AvDif'] ])
gknu=o_e.selectBestEstim (resarr)
t.add_row(['*', '*', '*', '*' ])
t.add_row([gknu['AvLogTruth'], gknu['SigmaLT'], gknu['b'], gknu['AvDif'] ])
print(t)
o_q.analyseDifList(gknu, imagename='ExtraStart_et_Aprior_Plan')
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)
def extraction_Kirch_DiodeV2Mod2DirectBranch():
"""
[Реестровая]
:return:
"""
funcf=func_Kirch_DiodeV2Mod2DirectBranch
jacf = Jac_Kirch_DiodeV2Mod2DirectBranch
c={}
Ve=np.array([ [0.0000000000001] ] )
btrue=[1.238e-14, 1.8, 1.5e-15, 1.9, 1.2, 0.5]
bstart=np.array(btrue)-np.array(btrue)*0.1
bend=np.array(btrue)+np.array(btrue)*0.1
binit=[1.238e-14, 1.7, 1.1e-20, 1.9, 1.1, 0.5]
xstart=[0.01]
#xend=[20,60]
xend=[1.5]
N=200 #число точек в плане (для планов, кроме априорного)
NArprior=30 #число точек в априорном плане
#Получаем априорный план
print("performing aprior plan:")
#блок кеширования априорного плана в файл
filename = os.path.basename(__file__).replace('.py','_plan1')
try:
oplan=o_p.readPlanFromFile(filename) #переключение на чтение априорного плана из файла
print ("Read file successful")
except BaseException as e:
oplan=o_ap.grandApriornPlanning (xstart, xend, NArprior, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbosePlan=True, verbose=True)[1]
o_p.writePlanToFile(oplan, filename)
#Задание опций для последовательного плана
terminationOptDict={'VdShelfPow':-7}
#Оценивание параметров с использованием ряда начальных значений
# resarr=list() #Список результатов
# t=PrettyTable (['Среднее логарифма правдоподобия','Сигма логарифма правдоподобия' , 'b','Среднее остатков по модулю'])
# for i in range(30):
# measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve)
# gknu=o_e.grandCountGN_UltraX_ExtraStart (funcf, jacf, measdata, bstart, bend, c, Ve, NSIG=100, implicit=False, verbose=False, Ntries=10, name='aprior plan plus several measurements')
# if (gknu):
# resarr.append(gknu)
# if resarr:
# for gknu in resarr:
# if (gknu):
# t.add_row([gknu['AvLogTruth'],gknu['SigmaLT'], gknu['b'], gknu['AvDif'] ])
# be=o_e.selectBestEstim (resarr)
#
# t.add_row(['*', '*', '*', '*' ])
# t.add_row([be['AvLogTruth'], be['SigmaLT'], be['b'], be['AvDif'] ])
# print(t)
# #o_q.analyseDifList(be)
# o_q.printGKNUNeat(be)
# o_q.printQualitatNeat(measdata, be[0], Ve, funcf, c)
#Оценивание с использованием binit
# По априорному плану
# print('Aprior Plan Binit')
# #данные по новому формату
#
# measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve)
# gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=100, implicit=False)
# #o_q.analyseDifList(gknu)
# o_q.printGKNUNeat(gknu)
# o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c)
#
# #По нормальному плану
print("performing normal research:")
startplan = o_p.makeUniformExpPlan(xstart, xend, 150)
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, startplan, btrue, c,Ve)
gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=100, implicit=False)
if (gknu):
#o_q.analyseDifList(gknu)
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu[0], Ve, funcf, c, jacf)
def extraction_DiodeV4_partIn_Decimal(plot=True):
"""
пробуем экстрагировать коэффициенты из модели диода
коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
входные параметры: напряжение, приложенное источником к системе резистор-диод
+-----------|||||---------->|--------- -
Резистор подключен до диода
:return:
"""
#возвращает значение y
funcf=solver_DiodeV4_partIn_Decimal
jacf = jac_DiodeV4_partIn_Decimal
#теперь попробуем сделать эксперимент.
c={}
Ve=np.array([ [0.00000001] ] )
btrue=[1.238e-14, 1.8, 100]
#btrue=[1.5e-14, 1.75, 150]
bstart=np.array(btrue)-np.array(btrue)*0.3
bend=np.array(btrue)+np.array(btrue)*0.3
binit=[1.0e-14, 1.7, 70]
#binit=[1.238e-14, 1.8, 100]
xstart=[0.001]
#xend=[20,60]
xend=[1.5]
N=100 #для неаприорных планов
NAprior=20 #для априорных планов
#Получаем априорный план
print("performing aprior plan:")
#блок кеширования априорного плана в файл
filename ='cachedPlans/'+os.path.basename(__file__).replace('.py','_plan')
try:
oplan=o_p.readPlanFromFile(filename) #переключение на чтение априорного плана из файла
print ("Read file successful")
except BaseException as e:
oplan=o_ap.grandApriornPlanning (xstart, xend, NAprior, bstart, bend, c, Ve, jacf, funcf, Ntries=6, verbosePlan=True, verbose=True)[1]
o_p.writePlanToFile(oplan, filename)
#}
unifplan = o_p.makeUniformExpPlan(xstart, xend, N)
#получаем измерения с планов
measdata = o_p.makeMeasAccToPlan_lognorm(funcf, oplan, btrue, c,Ve )
measdataUnif = o_p.makeMeasAccToPlan_lognorm(funcf, unifplan, btrue, c,Ve )
filename = os.path.basename(__file__).replace('.py','_results')
#выполняем оценку
print ("performing aprior plan")
gknu=o_e.grandCountGN_UltraX_Qualitat (funcf, jacf, measdata, binit, c, Ve, NSIG=100, implicit=True)
o_q.analyseDifList(gknu, imagename='Aprior_Plan')
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)
print ("performing uniform plan")
gknu=o_e.grandCountGN_UltraX_Qualitat (funcf, jacf, measdataUnif, binit, c, Ve, NSIG=100, implicit=True)
o_q.analyseDifList(gknu, imagename='Uniform_Plan')
o_q.printGKNUNeat(gknu)
o_q.printQualitatNeat(measdata, gknu['b'], Ve, funcf, c, jacf)
def testEstimateErlie():
#за 14-16 итераций с единичного вектора к результирующему с нулевой ошибкой, несмотря на разные порядки!!! при дисперсии 0.1 на 50 точках при обычном плане (учитывать большее число точек на самом деле)
#эпичная победа
"""
Пробуем произвести экстракцию параметров модели по параметрам транзистора Эрли
:return:
"""
jacf=lambda x,b,c,y: outTransParamErlieFormatJAC (x,b)
funcf=lambda x,b,c: outTransParamErlieFormat (x,b)
c={}
Ve=np.array([ [0.1, 0],
[0, 0.1] ] )
#BF,BR,IS,VA
#коэфф передачи по току в схеме с оэ нормальный режим, -//- реверсный, ток утечки, напряжение Эрли в активном режиме
btrue=[120,1,1.28e-15, 10]
#binit=[115,0.1,1, 11]
binit=[1]*len(btrue)
bstart=[100,0.5,1, 5]
bend=[125,2,2, 15]
xstart=[0.001,0.001]
xend=[4,4]
N=50
print("performing normal research:")
startplan = o_p.makeUniformExpPlan(xstart, xend, N)
measdata = o_p.makeMeasAccToPlan(funcf, startplan, btrue, c, Ve)
#надо добавить скажем априорный план, с фильтрованием точек
optimized_measdata=o_p.filterList(measdata, lim=1e55)
print ('Plan optimization: measdatalen={0} optimized={1}'.format(len(measdata), len(optimized_measdata )))
measdata = optimized_measdata
gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=10)
print (gknu)
print (o_q.getQualitat(measdata, gknu[0], Ve, funcf, c))
print (gknu[0])
#aprior plan
print("Performing aprior plan:")
oplan = o_ap.grandApriornPlanning(xstart, xend, 10, bstart, bend, c, Ve, jacf, Ntries=5)
o_p.writePlanToFile(oplan, 'Aprior plan Erlie')
measdata = o_p.makeMeasAccToPlan(funcf, oplan, btrue, c, Ve)
optimized_measdata=o_p.filterList(measdata, lim=1e55)
print ('Plan optimization: measdatalen={0} optimized={1}'.format(len(measdata), len(optimized_measdata )))
measdata = optimized_measdata
gknu=o_e.grandCountGN_UltraX1 (funcf, jacf, measdata, binit, c, NSIG=10)
print (gknu)
print (o_q.getQualitat(measdata, gknu[0], Ve, funcf, c))
