जावा में Google AI चैलेंज पर शुरू करें

मुझे आभासी दुनिया में वस्तुओं के व्यवहार की प्रोग्रामिंग के विषय में लंबे समय से दिलचस्पी है। लेकिन इस क्षेत्र में व्यावहारिक ज्ञान वांछित होने के लिए बहुत कुछ छोड़ देता है, इसलिए मैंने हाल ही में निवेश के लिए एक छोटी परियोजना की तलाश शुरू की। नतीजतन, मैंने पाया, मैं घोषणा के लिए Google और ideas4ru का आभारी हूं।

भाषा और स्टार्टर पैक

परियोजना आयोजकों ने बॉट के विकास के लिए एक दर्जन से अधिक भाषाओं की पेशकश की, मैंने जावा को चुना। मैं यह नहीं कह सकता कि मैं जावा को अच्छी तरह से जानता हूं, लेकिन यह हुआ (C ++ क्रिया है, PHP शांत नहीं है, C # बहुत नरम है, V8 से निपटने के लिए जावास्क्रिप्ट बहुत लंबा है, Lua सिंटैक्स की तरह नहीं है, पास्कल बहुत स्कूल की तरह है, पायथन - थोड़ा डरावना)। आप आधिकारिक वेबसाइट से या इस सीधे लिंक से जावा के लिए स्टार्टर पैक डाउनलोड कर सकते हैं।

मैंने कैसे शुरुआत की

शायद मैं एक ब्रेक हूं या मैं जावा को नहीं जानता, लेकिन शुरुआत में मुझे समझ नहीं आया कि कोड मुख्य वर्ग में कैसे काम करता है:

public void doTurn() { Ants ants = getAnts(); for (Tile myAnt : ants.getMyAnts()) { for (Aim direction : Aim.values()) { if (ants.getIlk(myAnt, direction).isPassable()) { ants.issueOrder(myAnt, direction); break; } } } } 

स्टार्टर पैक के पूरे कोड को पार्स करने में मुझे लगभग एक घंटे का समय लगा (मैं सभी को ऐसा ही करने की सलाह देता हूं, और जल्दी शुरू करने के तरीके पर लेख नहीं पढ़ता हूं)। नतीजतन, यह पता चला कि पहला चक्र अनुकूल चींटियों के साथ कोशिकाओं के माध्यम से चलता है, और दूसरा चींटी को चार दिशाओं (एआईएम के अनुक्रमिक गणन) में से एक में स्थानांतरित करने की कोशिश करता है।

पहले चरण में, मैं एक बहुत अच्छे नियम के साथ आया - जब आप दो चींटियों को एक ही सेल में ले जाते हैं, तो वे दोनों मर जाते हैं। इस समस्या को हल करने के लिए, चींटियों के वर्ग के लिए एक संशोधन किया गया था।

मैंने कब्जे वाली कोशिकाओं की एक सूची जोड़ी:

 public class Ants { private final Set<Tile> employed = new HashSet<Tile>(); //... 

अनुकूल चींटियों के पदों की सफाई करते समय, मैंने कब्जे वाले स्थानों की सफाई को जोड़ा:

 public void clearMyAnts() { employed.clear(); //... 

और अंत में, मैं लगभग पूरी तरह से समस्या को फिर से लिखता हूं।

 public boolean issueOrder(Tile myAnt, Aim direction) { Order order = new Order(myAnt, direction); Tile newPosition = getTile(myAnt, direction); if(getIlk(myAnt, direction).isPassable() && !employed.contains(newPosition)) { orders.add(order); //     ,     employed.add(newPosition); System.out.println(order); System.out.flush(); return true; } return false; } 

मुख्य वर्ग में कोड थोड़ा कम हो जाएगा:

 public void doTurn() { Ants ants = getAnts(); for (Tile myAnt : ants.getMyAnts()) { for (Aim direction : Aim.values()) { if (ants.issueOrder(myAnt, direction)) break; } } } 

थोड़ा व्यक्तित्व

हम थोड़ा सपना देखते हैं और कल्पना करते हैं कि भविष्य में, हमारा प्रत्येक चींटी एक व्यक्ति और कुछ मापदंडों का मालिक होगा। इस तरह के विचारों की निरंतरता चींटी वर्ग होगी:

 public class Ant { protected Ants ants; protected Tile tile; protected int waitStep = 0; public Ant(Ants ants, Tile tile) { this.tile = tile; this.ants = ants; } public Tile getTile() { return tile; } //      (   !) public boolean issueOrder(Aim direction) { if(ants.issueOrder(tile, direction)) { tile = ants.getTile(tile, direction); return true; } else return false; } //    ,      public boolean waiting() { return waitStep-- > 0; } //  public void think() { for(Aim direction : Aim.values()) { if(ants.issueOrder(direction)) break; } } } 

अगला, आपको इस वर्ग के काम करने के लिए काफी कुछ मामूली बदलाव करने की आवश्यकता है। यह बहुत उबाऊ और नीरस है, लेकिन फिर भी ... चलो MyBot विधि से शुरू करते हैं:

  public void doTurn() { getAnts().think(); //     } 

चींटियों के लिए लापता विधि जोड़ें और myAnts सूची की सामग्री प्रकार बदलें:

  private final Set<Ant> myAnts = new HashSet<Ant>(); //... public void think() { for(Ant ant : myAnts) { if(ant.waiting()) // ,    continue; ant.think(); //    } } 

अब आपको चींटी वस्तुओं को जोड़ने और हटाने की सावधानीपूर्वक निगरानी करने की आवश्यकता है। जिन लोगों को कोड का पता चला, उन्होंने सबसे अधिक संभावना चींटियों की कक्षा में अद्यतन पद्धति को देखा, जिसमें आप एक दोस्ताना चींटी और मौत की उपस्थिति को ट्रैक कर सकते हैं (लेकिन मृत्यु सभी चींटियों के लिए आम है)। इस आम मौत को कई तरीकों से ठीक किया जा सकता है ... मैंने दो तरह की मौत को जोड़ने का फैसला किया।

चलिए एल्क एन्यूमरेशन क्लास में बदलाव करते हैं:

 public enum Ilk { MY_DEAD, ENEMY_DEAD, //  DEAD, //... public boolean isUnoccupied() { return this == LAND || this == MY_DEAD || this == ENEMY_DEAD; } } 

बीओटी कक्षा में हटाने की विधि को समायोजित करें:

  public void removeAnt(int row, int col, int owner) { ants.update(owner > 0 ? Ilk.ENEMY_DEAD : Ilk.MY_DEAD, new Tile(row, col)); } 

अब चींटियों के "अवलोकन" करने के लिए सब कुछ तैयार है, एटीएस वर्ग में अपडेट विधि को संपादित करें:

  public void update(Ilk ilk, Tile tile) { map[tile.getRow()][tile.getCol()] = ilk; switch (ilk) { case FOOD: foodTiles.add(tile); break; case MY_ANT: myAnts.add(new Ant(this, tile)); break; case ENEMY_ANT: enemyAnts.add(tile); break; case MY_DEAD: myAnts.remove(new Ant(this, tile)); } } 

फूड एंड बुलशिट - अ लिटिल ब्रेन

इसके अलावा, सभी चरणों को चित्रित करने की कोशिश करने का कोई मतलब नहीं है, बस टिप्पणियों के साथ कोड दें। चींटी वर्ग कोड में परिवर्तन करके चींटी के व्यवहार को बदलें:

 public class Ant { //... public void think() { if(!doFood()) //   , doRandom(); //   } protected boolean doRandom() { while(!issueOrder(Aim.getRandom())); //     return true; } protected boolean doFood() { return moveToObject(ants.getFoodTiles()); } //        protected boolean moveToObject(Set<Tile> objects) { Tile object = findObject(objects); if(object != null) { issueOrder(ants.getDirections(object, tile).get(0)); return true; } return false; } //       protected Tile findObject(Set<Tile> objects) { Tile find = null; int distance = 0; int minDistance = ants.MAX_MAP_SIZE; for(Tile aspt : objects) { distance = ants.getDistance(aspt, tile); if(minDistance > distance) { find = aspt; minDistance = distance; } } return find; } } 

इस कोड को लिखते समय, मैंने Aim गणन वर्ग में एक स्थिर विधि जोड़ी जो एक यादृच्छिक दिशा देता है:

 public enum Aim { private static final Random random = new Random(); //... public static Aim getRandom() { return values()[random.nextInt(values().length)]; } } 

ग़लती

हो सकता है कि मैंने कोड में कहीं गड़बड़ कर दी हो, लेकिन यह Ants वर्ग की getDirections विधि में एक त्रुटि है।

  public List<Aim> getDirections(Tile t1, Tile t2) { List<Aim> directions = new ArrayList<Aim>(); if (t1.getRow() < t2.getRow()) { if (t2.getRow() - t1.getRow() >= rows / 2) { directions.add(Aim.SOUTH); // Aim.NORTH } else { directions.add(Aim.NORTH); // Aim.SOUTH } } else if (t1.getRow() > t2.getRow()) { if (t1.getRow() - t2.getRow() >= rows / 2) { directions.add(Aim.NORTH); //   ... } else { directions.add(Aim.SOUTH); //...    (  ) } } if (t1.getCol() < t2.getCol()) { if (t2.getCol() - t1.getCol() >= cols / 2) { directions.add(Aim.EAST); //   ... } else { directions.add(Aim.WEST); //...    (  ) } } else if (t1.getCol() > t2.getCol()) { if (t1.getCol() - t2.getCol() >= cols / 2) { directions.add(Aim.WEST); //   ... } else { directions.add(Aim.EAST); //...    (  ) } } return directions; } 

लंबे समय तक मैं समझ नहीं पाया कि क्या गलत था ... चींटी किसी भी तरह किसी भी तरह से भोजन की तलाश कर रही थी ... यह मामला निकला।

निष्कर्ष

मुझे नहीं लगता कि इस तरह के खेल के लिए आत्म-शिक्षा की आवश्यकता होती है। शायद रणनीतियों का एक सेट होना बेहतर होगा + एक छोटा समायोजन (समूह आकार, वर्तमान रणनीति ... मैं अभी अन्य मापदंडों का खुलासा नहीं करूंगा)। मुझे अभी तक यकीन नहीं है कि इस तरह की चींटियां कितनी प्रभावी होंगी, लेकिन मैं इस बारे में दूसरे लेख में लिखने की कोशिश करूंगा।

पुनश्च स्व-प्रशिक्षण आवश्यक नहीं है, क्योंकि यह एक बंद प्रणाली है जिसमें नए कारक दिखाई नहीं देते हैं। इस बीच, आत्म-सीखने वाला दुश्मन सीख रहा है, आप दुश्मन पहाड़ियों पर कब्जा कर सकते हैं :)