পাইথন, ২৪ টি পদক্ষেপ (কাজ চলছে)
ধারণাটি ছিল প্রথমে অবিচ্ছিন্ন সমস্যা সমাধানের জন্য, অনুসন্ধানের স্থানটি ব্যাপকভাবে হ্রাস করা এবং তারপরে ফলাফলটিকে গ্রিডে পরিমাণমুক্ত করা (কেবলমাত্র নিকটস্থ গ্রিডপয়েন্টে গোল করে এবং আশেপাশের 8 স্কোয়ারটি অনুসন্ধান করে)
আমি ট্রাইগনোমেট্রিক ফাংশনের সমষ্টি হিসাবে পথটিকে প্যারাম্যাট্রাইজ করি (বহুবচনগুলির বিপরীতে এগুলি বিচ্ছিন্ন করে না এবং চেক রাখা সহজ হয়)। আমি ত্বরণের পরিবর্তে সরাসরি গতিও নিয়ন্ত্রণ করি, কারণ শেষের দিকে 0-তে থাকে এমন একটি ওজনযুক্ত ফাংশন কেবলমাত্র গুণ করে বাউন্ডারি শর্তটি কার্যকর করা সহজ।
আমার উদ্দেশ্য ফাংশনটি
ত্বরণের জন্য এক্সফোনালিয়াল স্কোর নিয়ে > 10
শেষের পয়েন্ট এবং টার্গেটের মধ্যে ইউক্লিডিয়ান দূরত্বের জন্য পলিনোমোনাল স্কোর
- প্রাচীরের প্রতিটি প্রান্তের জন্য প্রতিটি চৌরাস্তার জন্য দীর্ঘ ধ্রুবক স্কোর, প্রাচীরের কিনার দিকে কমতে
স্কোর কমানোর জন্য, আমি এটি সবই ফেলেছি নেল্ডার-মিড অপটিমাইজেশনে ফেলেছি এবং কয়েক সেকেন্ড অপেক্ষা করি। অ্যালগরিদম সর্বদা শেষের দিকে যেতে সফল হয়, সেখানে থামে এবং সর্বাধিক ত্বরণ ছাড়িয়ে যায় না, তবে এতে দেয়ালগুলির সাথে ঝামেলা রয়েছে। পাথটি হয় কোণা দিয়ে টেলিপোর্ট করে এবং সেখানে আটকে যায়, বা দেয়ালের পাশ দিয়ে থামবে কেবল লক্ষ্য জুড়ে (বাম চিত্র)
পরীক্ষার সময় আমি ভাগ্যবান হয়েছি এবং এমন একটি পথ পেয়েছি যা একটি প্রতিশ্রুতিবদ্ধ উপায়ে (ডান চিত্র) ফাঁসানো হয়েছিল এবং পরামিতিগুলি টুইট করার পরে আরও একটি সফল অপ্টিমাইজেশনের জন্য এটি প্রাথমিক অনুমান হিসাবে ব্যবহার করতে পারলাম।
Quantization
প্যারামিট্রিক পাথ সন্ধানের পরে দশমিক পয়েন্টগুলি সরিয়ে ফেলার সময় হয়েছিল। 3x3 এর আশেপাশে অনুসন্ধান অনুসন্ধানের স্থানটি প্রায় 300 ^ N থেকে 9 ^ N পর্যন্ত হ্রাস করে, তবে এটি প্রয়োগ করা এখনও খুব বড় এবং বিরক্তিকর। আমি এই রাস্তায় নামার আগে আমি উদ্দেশ্যমূলক ক্রিয়ায় (মন্তব্য করা অংশগুলি) একটি "স্ন্যাপ টু গ্রিড" শব্দ যুক্ত করার চেষ্টা করেছি। সমাধানের জন্য আপডেট করা উদ্দেশ্য এবং কেবল বৃত্তাকারের সাথে অপ্টিমাইজেশনের আরও একশটি পদক্ষেপ যথেষ্ট ছিল।
[(9, -1), (4, 0), (1, 1), (2, 2), (-1, 2), (-3, 4), (-3, 3), (-2 , 3), (-2, 2), (-1, 1), (0, 0), (1, -2), (2, -3), (2, -2), (3, -5) ), (2, -4), (1, -5), (-2, -3), (-2, -4), (-3, -9), (-4, -4), (- 5, 8), (-4, 8), (5, 8)]
পদক্ষেপের সংখ্যা নির্ধারণ করা হয়েছিল এবং অপ্টিমাইজেশনের অংশ নয়, তবে যেহেতু আমাদের কাছে পথটির বিশ্লেষণাত্মক বিবরণ রয়েছে, (এবং যেহেতু সর্বাধিক ত্বরণটি 10 এর নিচে রয়েছে) আমরা এটি আরও কম সংখ্যক সহ আরও অপ্টিমাইজেশনের জন্য একটি প্রাথমিক পয়েন্ট হিসাবে পুনরায় ব্যবহার করতে পারি timesteps
from numpy import *
from scipy.optimize import fmin
import matplotlib.pyplot as plt
from matplotlib.collections import LineCollection as LC
walls = array([[[0,0],[500,0]], # [[x0,y0],[x1,y1]]
[[500,0],[500,400]],
[[500,400],[0,400]],
[[0,400],[0,0]],
[[200,200],[100,200]],
[[100,200],[100,100]],
[[100,100],[200,100]],
[[250,300],[250,200]],
[[300,300],[300,100]],
[[300,200],[400,200]],
[[300,100],[400,100]],
[[100,180],[120, 200]], #debug walls
[[100,120],[120, 100]],
[[300,220],[320, 200]],
#[[320,100],[300, 120]],
])
start = array([120,180])
goal = array([320,220])
###################################
# Boring stuff below, scroll down #
###################################
def weightedintersection2D(L1, L2):
# http://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
p = L1[0]
q = L2[0]
r = L1[1]-L1[0]
s = L2[1]-L2[0]
d = cross(r,s)
if d==0: # parallel
if cross(q-p,r)==0: return 1 # overlap
else:
t = cross(q-p,s)*1.0/d
u = cross(q-p,r)*1.0/d
if 0<=t<=1 and 0<=u<=1: return 1-0*abs(t-.5)-1*abs(u-.5) # intersect at p+tr=q+us
return 0
def sinsum(coeff, tt):
'''input: list of length 2(2k+1),
first half for X-movement, second for Y-movement.
Of each, the first k elements are sin-coefficients
the next k+1 elements are cos-coefficients'''
N = len(coeff)/2
XS = [0]+list(coeff[:N][:N/2])
XC = coeff[:N][N/2:]
YS = [0]+list(coeff[N:][:N/2])
YC = coeff[N:][N/2:]
VX = sum([XS[i]*sin(tt*ww[i]) + XC[i]*cos(tt*ww[i]) for i in range(N/2+1)], 0)
VY = sum([YS[i]*sin(tt*ww[i]) + YC[i]*cos(tt*ww[i]) for i in range(N/2+1)], 0)
return VX*weightfunc, VY*weightfunc
def makepath(vx, vy):
# turn coordinates into line segments, to check for intersections
xx = cumsum(vx)+start[0]
yy = cumsum(vy)+start[1]
path = []
for i in range(1,len(xx)):
path.append([[xx[i-1], yy[i-1]],[xx[i], yy[i]]])
return path
def checkpath(path):
intersections = 0
for line1 in path[:-1]: # last two elements are equal, and thus wrongly intersect each wall
for line2 in walls:
intersections += weightedintersection2D(array(line1), array(line2))
return intersections
def eval_score(coeff):
# tweak everything for better convergence
vx, vy = sinsum(coeff, tt)
path = makepath(vx, vy)
score_int = checkpath(path)
dist = hypot(*(path[-1][1]-goal))
score_pos = abs(dist)**3
acc = hypot(diff(vx), diff(vy))
score_acc = sum(exp(clip(3*(acc-10), -10,20)))
#score_snap = sum(abs(diff(vx)-diff(vx).round())) + sum(abs(diff(vy)-diff(vy).round()))
print score_int, score_pos, score_acc#, score_snap
return score_int*100 + score_pos*.5 + score_acc #+ score_snap
######################################
# Boring stuff above, scroll to here #
######################################
Nw = 4 # <3: paths not squiggly enough, >6: too many dimensions, slow
ww = [1*pi*k for k in range(Nw)]
Nt = 30 # find a solution with tis many steps
tt = linspace(0,1,Nt)
weightfunc = tanh(tt*30)*tanh(30*(1-tt)) # makes sure end velocity is 0
guess = random.random(4*Nw-2)*10-5
guess = array([ 5.72255365, -0.02720178, 8.09631272, 1.88852287, -2.28175362,
2.915817 , 8.29529905, 8.46535503, 5.32069444, -1.7422171 ,
-3.87486437, 1.35836498, -1.28681144, 2.20784655]) # this is a good start...
array([ 10.50877078, -0.1177561 , 4.63897574, -0.79066986,
3.08680958, -0.66848585, 4.34140494, 6.80129358,
5.13853914, -7.02747384, -1.80208349, 1.91870184,
-4.21784737, 0.17727804]) # ...and it returns this solution
optimsettings = dict(
xtol = 1e-6,
ftol = 1e-6,
disp = 1,
maxiter = 1000, # better restart if not even close after 300
full_output = 1,
retall = 1)
plt.ion()
plt.axes().add_collection(LC(walls))
plt.xlim(-10,510)
plt.ylim(-10,410)
path = makepath(*sinsum(guess, tt))
plt.axes().add_collection(LC(path, color='red'))
plt.plot(*start, marker='o')
plt.plot(*goal, marker='o')
plt.show()
optres = fmin(eval_score, guess, **optimsettings)
optcoeff = optres[0]
#for c in optres[-1][::optimsettings['maxiter']/10]:
for c in array(optres[-1])[logspace(1,log10(optimsettings['maxiter']-1), 10).astype(int)]:
vx, vy = sinsum(c, tt)
path = makepath(vx,vy)
plt.axes().add_collection(LC(path, color='green'))
plt.show()
করণীয়: জিইউআই যা আপনাকে মোটামুটি দিকনির্দেশনার জন্য প্রাথমিক পথ আঁকতে দেয়। 14-মাত্রিক স্থান থেকে এলোমেলোভাবে নমুনা দেওয়ার চেয়ে যে কোনও কিছুই ভাল
