Alpas

alpas

Authors:
(1) Aya Kherrour, Department of Information Engineering and Computer Science University of Trento;
(2) Marco Robol, Department of Information Engineering and Computer Science University of Trento;
(3) Marco Roveri, Department of Information Engineering and Computer Science University of Trento;
(4) Paolo Giorgini, Department of Information Engineering and Computer Science University of Trento. 6 Conclusion This work aimed to evaluate the performance of several known heuristic search algorithms, such as D*, D* Lite, LPA*, LRTA*, RTAA*, and ARA* in terms of solving time, memory consumption, and path cost. The evaluation was made using different randomly generated grid environments with different characteristics alongside personalized grid environments with horizontal walls and different wall lengths as different hinders. Our experimental evaluation revealed that all the algorithms exhibit different performances with strengths and weaknesses under different grid characterizations. D* Lite consistently generated the shortest paths even in obstacle-dense grids, indicating its efficiency in dense environments. ARA* consistently provides faster solutions as the grid size increases, particularly larger than 100, while RTTA* generates faster solutions in smaller grid sizes, with the advantage of not being affected by dense environments. Our study provides valuable insights into selecting the appropriate heuristic search algorithm in the pathfinding domain. Using these insights, we propose a selection algorithm used to optimize the performance needed in a pathfinding domain, such as, solving time, path length, or memory consumption. However, our evaluation focused only on static environments, while dynamic environments may introduce additional challenges. Furthermore, we considered a limited set of experiments, not covering all possible combinations of the grid characteristics. This limitation means that the selection algorithm might not always recommend the most optimal solution, as seen in the example we introduced to evaluate our algorithm. In future work, we aim to address these limitations as follows: Firstly, we plan to extend our evaluation of the search algorithms to include dynamic environments. Secondly, we intend to explore various combinations of both domain characterization and priorities. Furthermore, we want to include additional scenario configuration, extending the random obstacles and the walls scenarios. With such additional understanding, we aim to refine our selection algorithm to automatically take decisions among the best search algorithms, based on the type of obstacles in the local search space. References [1] Nafiz Arica, Aysegul Mut, Alper Yörükçü & Kadir Alpaslan Demir (2017): An Empirical Comparison of Search Approaches for Moving Agents. Comput. Intell. 33(3), pp. 368–400, doi:10.1111/coin.12092. [2] Yngvi Björnsson, Vadim Bulitko & Nathan R. Sturtevant (2009): TBA*: Time-Bounded A*. In Craig Boutilier, editor: IJCAI 2009, Proceedings of the 21st International Joint Conference on Artificial Intelligence, Pasadena, California, USA, July 11-17, 2009, pp. 431–436. Available at http://ijcai.org/ Proceedings/09/Papers/079.pdf. [3] David Bond, Niels A. Widger, Wheeler Ruml & Xiaoxun Sun (2010): Real-Time Search in Dynamic Worlds. In Ariel Felner & Nathan R. Sturtevant, editors: Proceedings of the Third Annual Symposium on Combinatorial Search, SOCS 2010, Stone Mountain, Atlanta, Georgia, USA, July 8 10, 2010, AAAI Press, doi:10.1609/socs.v1i1.18174. Available at http://aaai.org/ocs/index.php/SOCS/SOCS10/paper/ view/2103. [4] Guillaume Brat, Ewen Denney, Dimitra Giannakopoulou, Jeremy Frank & Ari Jónsson (2006): Verification of autonomous systems for space applications. In: 2006 IEEE Aerospace Conference, IEEE, pp. 11–pp, doi:10.1109/AERO.2006.1656029. [5] Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest & Clifford Stein (2009): Introduction to Algorithms, 3rd Edition. MIT Press. Available at http://mitpress.mit.edu/books/ introduction-algorithms. [6] A. Elfes (1989): Using occupancy grids for mobile robot perception and navigation. Computer 22(6), pp. 46–57, doi:10.1109/2.30720. [7] Carlos Hernández & Jorge A. Baier (2011): Real-Time Heuristic Search with Depression Avoidance. In Toby Walsh, editor: IJCAI 2011, Proceedings of the 22nd International Joint Conference on Artificial Intelligence, Barcelona, Catalonia, Spain, July 16-22, 2011, IJCAI/AAAI, pp. 578–583, doi:10.5591/978-1-57735-516- 8/IJCAI11-104. [8] Mohd Javaid, Abid Haleem, Ravi Pratap Singh & Rajiv Suman (2021): Substantial capabilities of robotics in enhancing industry 4.0 implementation. Cognitive Robotics 1, pp. 58–75, doi:10.1016/j.cogr.2021.06.001. [9] Sven Koenig (2001): Agent-Centered Search. AI Mag. 22(4), pp. 109–132, doi:10.1609/aimag.v22i4.1596. [10] Sven Koenig (2004): A Comparison of Fast Search Methods for Real-Time Situated Agents, pp. 864–871. doi:10.1109/AAMAS.2004.10122. Available at https://doi.ieeecomputersociety.org/10.1109/ AAMAS.2004.10122. [11] Sven Koenig & Maxim Likhachev (2002): D*Lite, pp. 476–483. Available at http://www.aaai.org/ Library/AAAI/2002/aaai02-072.php. [12] Sven Koenig & Maxim Likhachev (2006): Real-time adaptive A*. In Hideyuki Nakashima, Michael P. Wellman, Gerhard Weiss & Peter Stone, editors: 5th International Joint Conference on Autonomous Agents and Multiagent Systems (AAMAS 2006), Hakodate, Japan, May 8-12, 2006, ACM, pp. 281–288, doi:10.1145/1160633.1160682. [13] Sven Koenig & Xiaoxun Sun (2009): Comparing real-time and incremental heuristic search for real-time situated agents. Auton. Agents Multi Agent Syst. 18(3), pp. 313–341, doi:10.1007/s10458 008-9061-x. [14] Richard E Korf (1990): Real-time heuristic search. Artificial intelligence 42(2-3), pp. 189–211, doi:10.1016/0004-3702(90)90054-4. [15] Maxim Likhachev, Geoffrey J. Gordon & Sebastian Thrun (2003): ARA*: Anytime A* with Provable Bounds on Sub-Optimality, pp. 767–774. Available at https://proceedings.neurips.cc/paper/2003/hash/ ee8fe9093fbbb687bef15a38facc44d2-Abstract.html. [16] Manuel Müller, Timo Müller, Behrang Ashtari Talkhestani, Philipp Marks, Nasser Jazdi & Michael Weyrich (2021): Industrial autonomous systems: a survey on definitions, characteristics and abilities. atAutomatisierungstechnik 69(1), pp. 3–13, doi:10.1515/auto-2020-0131. [17] Michal Pechoucek, Simon G Thompson & Holger Voos (2008): Defence Industry Applications of Autonomous Agents and Multi-Agent Systems. Springer, doi:10.1007/978-3-7643-8571-2. [18] Francisco J Perez-Grau, J Ramiro Martinez-de Dios, Julio L Paneque, J Joaquin Acevedo, Arturo Torres-González, Antidio Viguria, Juan R Astorga & Anibal Ollero (2021): Introducing autonomous aerial robots in industrial manufacturing. Journal of Manufacturing Systems 60, pp. 312–324, doi:10.1016/j.jmsy.2021.06.008. [19] José Ricardo Sánchez-Ibáñez, Carlos Jesús Pérez-del-Pulgar & Alfonso García-Cerezo (2021): Path Planning for Autonomous Mobile Robots: A Review. Sensors 21(23), p. 7898, doi:10.3390/s21237898. [20] Anthony Stentz (1995): The Focussed D* Algorithm for Real-Time Replanning. In: Proceedings of the Fourteenth International Joint Conference on Artificial Intelligence, IJCAI 95, Montréal Québec, Canada, August 20-25 1995, 2 Volumes, Morgan Kaufmann, pp. 1652–1659. Available at http://ijcai.org/ Proceedings/95-2/Papers/082.pdf. [21] Dmitry S. Yershov & Steven M. LaValle (2011): Simplicial Dijkstra and A* algorithms for optimal feedback planning. In: 2011 IEEE/RSJ International Conference on Intelligent Robots and Systems, IROS 2011, San Francisco, CA, USA, September 25-30, 2011, IEEE, pp. 3862–3867, doi:10.1109/IROS.2011.6095032. This paper is available on arxiv under CC 4.0 license. Authors: (1) Aya Kherrour, Department of Information Engineering and Computer Science University of Trento; (2) Marco Robol, Department of Information Engineering and Computer Science University of Trento; (3) Marco Roveri, Department of Information Engineering and Computer Science University of Trento; (4) Paolo Giorgini, Department of Information Engineering and Computer Science University of Trento. Authors: (1) Aya Kherrour, Department of Information Engineering and Computer Science University of Trento; (2) Marco Robol, Department of Information Engineering and Computer Science University of Trento; (3) Marco Roveri, Department of Information Engineering and Computer Science University of Trento; (4) Paolo Giorgini, Department of Information Engineering and Computer Science University of Trento. 6 Conclusion This work aimed to evaluate the performance of several known heuristic search algorithms, such as D*, D* Lite, LPA*, LRTA*, RTAA*, and ARA* in terms of solving time, memory consumption, and path cost. The evaluation was made using different randomly generated grid environments with different characteristics alongside personalized grid environments with horizontal walls and different wall lengths as different hinders. Our experimental evaluation revealed that all the algorithms exhibit different performances with strengths and weaknesses under different grid characterizations. D* Lite consistently generated the shortest paths even in obstacle-dense grids, indicating its efficiency in dense environments. ARA* consistently provides faster solutions as the grid size increases, particularly larger than 100, while RTTA* generates faster solutions in smaller grid sizes, with the advantage of not being affected by dense environments. Our study provides valuable insights into selecting the appropriate heuristic search algorithm in the pathfinding domain. Using these insights, we propose a selection algorithm used to optimize the performance needed in a pathfinding domain, such as, solving time, path length, or memory consumption. However, our evaluation focused only on static environments, while dynamic environments may introduce additional challenges. Furthermore, we considered a limited set of experiments, not covering all possible combinations of the grid characteristics. This limitation means that the selection algorithm might not always recommend the most optimal solution, as seen in the example we introduced to evaluate our algorithm. In future work, we aim to address these limitations as follows: Firstly, we plan to extend our evaluation of the search algorithms to include dynamic environments. Secondly, we intend to explore various combinations of both domain characterization and priorities. Furthermore, we want to include additional scenario configuration, extending the random obstacles and the walls scenarios. With such additional understanding, we aim to refine our selection algorithm to automatically take decisions among the best search algorithms, based on the type of obstacles in the local search space. References [1] Nafiz Arica, Aysegul Mut, Alper Yörükçü & Kadir Alpaslan Demir (2017): An Empirical Comparison of Search Approaches for Moving Agents. Comput. Intell. 33(3), pp. 368–400, doi:10.1111/coin.12092. [2] Yngvi Björnsson, Vadim Bulitko & Nathan R. Sturtevant (2009): TBA*: Time-Bounded A*. In Craig Boutilier, editor: IJCAI 2009, Proceedings of the 21st International Joint Conference on Artificial Intelligence, Pasadena, California, USA, July 11-17, 2009, pp. 431–436. Available at http://ijcai.org/ Proceedings/09/Papers/079.pdf. [3] David Bond, Niels A. Widger, Wheeler Ruml & Xiaoxun Sun (2010): Real-Time Search in Dynamic Worlds. In Ariel Felner & Nathan R. Sturtevant, editors: Proceedings of the Third Annual Symposium on Combinatorial Search, SOCS 2010, Stone Mountain, Atlanta, Georgia, USA, July 8 10, 2010, AAAI Press, doi:10.1609/socs.v1i1.18174. Available at http://aaai.org/ocs/index.php/SOCS/SOCS10/paper/ view/2103. [4] Guillaume Brat, Ewen Denney, Dimitra Giannakopoulou, Jeremy Frank & Ari Jónsson (2006): Verification of autonomous systems for space applications. In: 2006 IEEE Aerospace Conference, IEEE, pp. 11–pp, doi:10.1109/AERO.2006.1656029. [5] Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest & Clifford Stein (2009): Introduction to Algorithms, 3rd Edition. MIT Press. Available at http://mitpress.mit.edu/books/ introduction-algorithms. [6] A. Elfes (1989): Using occupancy grids for mobile robot perception and navigation. Computer 22(6), pp. 46–57, doi:10.1109/2.30720. [7] Carlos Hernández & Jorge A. Baier (2011): Real-Time Heuristic Search with Depression Avoidance. In Toby Walsh, editor: IJCAI 2011, Proceedings of the 22nd International Joint Conference on Artificial Intelligence, Barcelona, Catalonia, Spain, July 16-22, 2011, IJCAI/AAAI, pp. 578–583, doi:10.5591/978-1-57735-516- 8/IJCAI11-104. [8] Mohd Javaid, Abid Haleem, Ravi Pratap Singh & Rajiv Suman (2021): Substantial capabilities of robotics in enhancing industry 4.0 implementation. Cognitive Robotics 1, pp. 58–75, doi:10.1016/j.cogr.2021.06.001. [9] Sven Koenig (2001): Agent-Centered Search. AI Mag. 22(4), pp. 109–132, doi:10.1609/aimag.v22i4.1596. [10] Sven Koenig (2004): A Comparison of Fast Search Methods for Real-Time Situated Agents, pp. 864–871. doi:10.1109/AAMAS.2004.10122. Available at https://doi.ieeecomputersociety.org/10.1109/ AAMAS.2004.10122. [11] Sven Koenig & Maxim Likhachev (2002): D*Lite, pp. 476–483. Available at http://www.aaai.org/ Library/AAAI/2002/aaai02-072.php. [12] Sven Koenig & Maxim Likhachev (2006): Real-time adaptive A*. In Hideyuki Nakashima, Michael P. Wellman, Gerhard Weiss & Peter Stone, editors: 5th International Joint Conference on Autonomous Agents and Multiagent Systems (AAMAS 2006), Hakodate, Japan, May 8-12, 2006, ACM, pp. 281–288, doi:10.1145/1160633.1160682. [13] Sven Koenig & Xiaoxun Sun (2009): Comparing real-time and incremental heuristic search for real-time situated agents. Auton. Agents Multi Agent Syst. 18(3), pp. 313–341, doi:10.1007/s10458 008-9061-x. [14] Richard E Korf (1990): Real-time heuristic search. Artificial intelligence 42(2-3), pp. 189–211, doi:10.1016/0004-3702(90)90054-4. [15] Maxim Likhachev, Geoffrey J. Gordon & Sebastian Thrun (2003): ARA*: Anytime A* with Provable Bounds on Sub-Optimality, pp. 767–774. Available at https://proceedings.neurips.cc/paper/2003/hash/ ee8fe9093fbbb687bef15a38facc44d2-Abstract.html. [16] Manuel Müller, Timo Müller, Behrang Ashtari Talkhestani, Philipp Marks, Nasser Jazdi & Michael Weyrich (2021): Industrial autonomous systems: a survey on definitions, characteristics and abilities. atAutomatisierungstechnik 69(1), pp. 3–13, doi:10.1515/auto-2020-0131. [17] Michal Pechoucek, Simon G Thompson & Holger Voos (2008): Defence Industry Applications of Autonomous Agents and Multi-Agent Systems. Springer, doi:10.1007/978-3-7643-8571-2. [18] Francisco J Perez-Grau, J Ramiro Martinez-de Dios, Julio L Paneque, J Joaquin Acevedo, Arturo Torres-González, Antidio Viguria, Juan R Astorga & Anibal Ollero (2021): Introducing autonomous aerial robots in industrial manufacturing. Journal of Manufacturing Systems 60, pp. 312–324, doi:10.1016/j.jmsy.2021.06.008. [19] José Ricardo Sánchez-Ibáñez, Carlos Jesús Pérez-del-Pulgar & Alfonso García-Cerezo (2021): Path Planning for Autonomous Mobile Robots: A Review. Sensors 21(23), p. 7898, doi:10.3390/s21237898. [20] Anthony Stentz (1995): The Focussed D* Algorithm for Real-Time Replanning. In: Proceedings of the Fourteenth International Joint Conference on Artificial Intelligence, IJCAI 95, Montréal Québec, Canada, August 20-25 1995, 2 Volumes, Morgan Kaufmann, pp. 1652–1659. Available at http://ijcai.org/ Proceedings/95-2/Papers/082.pdf. [21] Dmitry S. Yershov & Steven M. LaValle (2011): Simplicial Dijkstra and A* algorithms for optimal feedback planning. In: 2011 IEEE/RSJ International Conference on Intelligent Robots and Systems, IROS 2011, San Francisco, CA, USA, September 25-30, 2011, IEEE, pp. 3862–3867, doi:10.1109/IROS.2011.6095032. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

Future Directions in Heuristic Search

Favor immutability to retain control of your objects TL;DR: Use immutable objects to prevent unexpected changes caused by aliasing. Problems Unexpected mutations
Difficult bug tracking
Unpredictable code behavior
Reduced code predictability
Increased coupling
Compromised thread safety Solutions Use immutable objects
Implement defensive copying
Favor functional programming Refactorings https://maximilianocontieri.com/refactoring-008-convert-variables-to-constant?embedable=true Context Aliasing happens when multiple references point to the same mutable object. This can lead to unexpected changes in them when one part of the code modifies the object, affecting all references. Immutable objects mitigate this risk by ensuring you cannot change their internal representation once you create an object. Collection Aliasing is a notable example of this issue. Sample Code Wrong public class Person {
  private String name; 
}

public void modifyPerson(Person person) {
  person.setName("Cosmo Kramer");
}

public static void main(String[] args) {
  Person p1 = new Person("Newman");
  Person p2 = p1; // p1 and p2 refer to the same object

  modifyPerson(p1);

  System.out.println(p1.name()); // Output: Cosmo Kramer
  System.out.println(p2.name()); // Output: Cosmo Kramer (unexpected)
} Right public class ImmutablePerson {
  private final String name; 

  public ImmutablePerson(String name) {
    this.name = name; 
  } 
}

public ImmutablePerson withName(String newName) {
    return new ImmutablePerson(newName);
}

public static void main(String[] args) {
  ImmutablePerson p1 = new ImmutablePerson("Newman");
  ImmutablePerson p2 = p1; // p1 and p2 refer to the same object

  // Modifying p1 creates a new object
  ImmutablePerson p3 = p1.withName("Cosmo Kramer");
  // but this is a bad practice 
  // since only constructors should create new objects
  // A better option is
  ImmutablePerson p3 = new ImmutablePerson("Cosmo Kramer");

  System.out.println(p1.name()); // Output: Newman
  System.out.println(p2.name()); // Output: Newman
  System.out.println(p3.name()); // Output: Cosmo Kramer
} Detection [x]Semi-Automatic You can detect this smell by reviewing your code for mutable objects shared across different parts of your program. Tag(s) Mutability Level [x]Intermediate AI Generation AI generators might introduce this smell if they're not specifically trained to prioritize immutability and avoid aliasing issues. AI Detection AI detectors identify this smell by analyzing code for mutable shared objects and suggesting immutable alternatives. They need specific instructions on the context and the importance of immutability in the codebase. Try Them! Remember AI Assistants make lots of mistakes ChatGPT	 Claude
Perplexity
Gemini Conclusion Using immutable objects and avoiding aliasing can significantly improve your code's predictability, reduces bugs, and improves thread safety. It requires a shift in thinking and the benefits of immutability far outweigh the initial learning curve. Related Reading https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxvi https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi https://hackernoon.com/code-smell-266-collection-aliasing?embedable=true https://hackernoon.com/is-it-crystal-clear-for-everybody-that-a-date-should-not-mutate-wuoy3z03?embedable=true Disclaimer: Code Smells are my opinion. Credits: Photo by Natural Photos on Unsplash Immutability changes everything. Pat Helland https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true This article is part of the CodeSmell Series on HackerNoon: How to Find the Stinky Parts of your Code Favor immutability to retain control of your objects Favor immutability to retain control of your objects TL;DR: Use immutable objects to prevent unexpected changes caused by aliasing. TL;DR: Use immutable objects to prevent unexpected changes caused by aliasing. Problems Unexpected mutations Difficult bug tracking Unpredictable code behavior Reduced code predictability Increased coupling Compromised thread safety Unexpected mutations mutations Difficult bug tracking Unpredictable code behavior Reduced code predictability Increased coupling Compromised thread safety Solutions Use immutable objects Implement defensive copying Favor functional programming Use immutable objects Implement defensive copying Favor functional programming Refactorings https://maximilianocontieri.com/refactoring-008-convert-variables-to-constant?embedable=true https://maximilianocontieri.com/refactoring-008-convert-variables-to-constant?embedable=true Context Aliasing happens when multiple references point to the same mutable object. This can lead to unexpected changes in them when one part of the code modifies the object, affecting all references. Immutable objects mitigate this risk by ensuring you cannot change their internal representation once you create an object. Collection Aliasing is a notable example of this issue. Collection Aliasing Sample Code Wrong public class Person {
  private String name; 
}

public void modifyPerson(Person person) {
  person.setName("Cosmo Kramer");
}

public static void main(String[] args) {
  Person p1 = new Person("Newman");
  Person p2 = p1; // p1 and p2 refer to the same object

  modifyPerson(p1);

  System.out.println(p1.name()); // Output: Cosmo Kramer
  System.out.println(p2.name()); // Output: Cosmo Kramer (unexpected)
} public class Person {
  private String name; 
}

public void modifyPerson(Person person) {
  person.setName("Cosmo Kramer");
}

public static void main(String[] args) {
  Person p1 = new Person("Newman");
  Person p2 = p1; // p1 and p2 refer to the same object

  modifyPerson(p1);

  System.out.println(p1.name()); // Output: Cosmo Kramer
  System.out.println(p2.name()); // Output: Cosmo Kramer (unexpected)
} Right public class ImmutablePerson {
  private final String name; 

  public ImmutablePerson(String name) {
    this.name = name; 
  } 
}

public ImmutablePerson withName(String newName) {
    return new ImmutablePerson(newName);
}

public static void main(String[] args) {
  ImmutablePerson p1 = new ImmutablePerson("Newman");
  ImmutablePerson p2 = p1; // p1 and p2 refer to the same object

  // Modifying p1 creates a new object
  ImmutablePerson p3 = p1.withName("Cosmo Kramer");
  // but this is a bad practice 
  // since only constructors should create new objects
  // A better option is
  ImmutablePerson p3 = new ImmutablePerson("Cosmo Kramer");

  System.out.println(p1.name()); // Output: Newman
  System.out.println(p2.name()); // Output: Newman
  System.out.println(p3.name()); // Output: Cosmo Kramer
} public class ImmutablePerson {
  private final String name; 

  public ImmutablePerson(String name) {
    this.name = name; 
  } 
}

public ImmutablePerson withName(String newName) {
    return new ImmutablePerson(newName);
}

public static void main(String[] args) {
  ImmutablePerson p1 = new ImmutablePerson("Newman");
  ImmutablePerson p2 = p1; // p1 and p2 refer to the same object

  // Modifying p1 creates a new object
  ImmutablePerson p3 = p1.withName("Cosmo Kramer");
  // but this is a bad practice 
  // since only constructors should create new objects
  // A better option is
  ImmutablePerson p3 = new ImmutablePerson("Cosmo Kramer");

  System.out.println(p1.name()); // Output: Newman
  System.out.println(p2.name()); // Output: Newman
  System.out.println(p3.name()); // Output: Cosmo Kramer
} Detection [x]Semi-Automatic [x] Semi-Automatic [x] You can detect this smell by reviewing your code for mutable objects shared across different parts of your program. Tag(s) Mutability Mutability Level [x]Intermediate [x] Intermediate [x] AI Generation AI generators might introduce this smell if they're not specifically trained to prioritize immutability and avoid aliasing issues. AI Detection AI detectors identify this smell by analyzing code for mutable shared objects and suggesting immutable alternatives. They need specific instructions on the context and the importance of immutability in the codebase. Try Them! Remember AI Assistants make lots of mistakes Remember AI Assistants make lots of mistakes ChatGPT Claude Perplexity Gemini ChatGPT Claude Perplexity Gemini Conclusion Using immutable objects and avoiding aliasing can significantly improve your code's predictability, reduces bugs, and improves thread safety. It requires a shift in thinking and the benefits of immutability far outweigh the initial learning curve. Related Reading https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxvi https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxvi https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi https://hackernoon.com/code-smell-266-collection-aliasing?embedable=true https://hackernoon.com/code-smell-266-collection-aliasing?embedable=true https://hackernoon.com/is-it-crystal-clear-for-everybody-that-a-date-should-not-mutate-wuoy3z03?embedable=true https://hackernoon.com/is-it-crystal-clear-for-everybody-that-a-date-should-not-mutate-wuoy3z03?embedable=true Disclaimer: Code Smells are my opinion. Disclaimer: Code Smells are my opinion . opinion Credits: Photo by Natural Photos on Unsplash Credits: Photo by Natural Photos on Unsplash Natural Photos Unsplash Immutability changes everything. Immutability changes everything. Pat Helland Pat Helland https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true This article is part of the CodeSmell Series on HackerNoon: How to Find the Stinky Parts of your Code This article is part of the CodeSmell Series on HackerNoon: How to Find the Stinky Parts of your Code How to Find the Stinky Parts of your Code

Code Smell 267 - Objects Aliasing

Exposing your collections couples your solution TL;DR: Use immutable collections to prevent unintended side effects. Problems Unpredictable behavior
Debugging challenges
Data corruption
Violation of the Principle of Least Astonishment
Premature optimization
Unexpected Mutations
Concurrency problems
Compromised thread safety
Increased coupling Solutions Use immutable collections
Create immutable classes
Copy the collection before modification
Avoid collection getters
Avoid automatic properties
Favor information hiding and encapsulation Context Aliasing happens when two or more variables refer to the same object. This can lead to unexpected side effects, especially when one variable modifies the shared object. You can't change immutable collections after creation helping you prevent accidental aliasing. Premature optimizators will argue that copying collections is an expensive operation that you should avoid. This is a special case of Object Aliasing Sample Code Wrong public class MutableExample {
  public static void main(String[] args) {
    List<Integer> numbers = List.of(1, 2, 3);
    List<Integer> otherNumbers = numbers; // Aliasing
    otherNumbers.add(4);
    System.out.println(numbers); // Output: [1, 2, 3, 4]
  }
} Right public class ImmutableExample {
  public static void main(String[] args) {
    List<Integer> numbers = List.of(1, 2, 3);
    List<Integer> otherNumbers = List.copyOf(numbers); // Creating a copy
    otherNumbers.add(4);
    System.out.println(numbers); // Output: [1, 2, 3]
  }
} Detection [x]Semi-Automatic Several static analysis tools can warn you of aliasing abuse. Tags Immutability Level [x]Intermediate AI Generation AI code generators might not always create immutable objects by default, especially when working with mutable collections. You can prompt them to prioritize immutable collections and wrap existing ones to avoid aliasing. AI Detection AI tools can analyze code for potential aliasing issues and suggest using immutable collections instead. Conclusion You can avoid unintended side effects using immutable collections. This will make your code more predictable and easier to reason about. Related Reading https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xviii https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi https://hackernoon.com/finding-the-stinky-parts-of-your-code-code-smell-256-mutable-getters https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxii https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xiv More Info https://hackernoon.com/is-it-crystal-clear-for-everybody-that-a-date-should-not-mutate-wuoy3z03?embedable=true https://hackernoon.com/nude-models-part-ii-getters-sjo3ua2?embedable=true https://hackernoon.com/coupling-the-one-and-only-software-designing-problem-9z5a321h?embedable=true Disclaimer: Code Smells are my opinion. Credits: Photo by Martino Pietropoli on Unsplash If an object is immutable, it can be in only one state, and you win big. Joshua Bloch https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true This article is part of the CodeSmell Series on HackerNoon: How to Find the Stinky Parts of your Code Exposing your collections couples your solution Exposing your collections couples your solution TL;DR: Use immutable collections to prevent unintended side effects. TL;DR: Use immutable collections to prevent unintended side effects. Problems Unpredictable behavior Debugging challenges Data corruption Violation of the Principle of Least Astonishment Premature optimization Unexpected Mutations Concurrency problems Compromised thread safety Increased coupling Unpredictable behavior Debugging challenges Data corruption Violation of the Principle of Least Astonishment Premature optimization Unexpected Mutations Mutations Concurrency problems Compromised thread safety Increased coupling coupling Solutions Use immutable collections Create immutable classes Copy the collection before modification Avoid collection getters Avoid automatic properties Favor information hiding and encapsulation Use immutable collections Create immutable classes Copy the collection before modification Avoid collection getters collection getters Avoid automatic properties automatic properties Favor information hiding and encapsulation Context Aliasing happens when two or more variables refer to the same object. This can lead to unexpected side effects, especially when one variable modifies the shared object. You can't change immutable collections after creation helping you prevent accidental aliasing. Premature optimizators will argue that copying collections is an expensive operation that you should avoid. This is a special case of Object Aliasing Sample Code Wrong public class MutableExample {
  public static void main(String[] args) {
    List<Integer> numbers = List.of(1, 2, 3);
    List<Integer> otherNumbers = numbers; // Aliasing
    otherNumbers.add(4);
    System.out.println(numbers); // Output: [1, 2, 3, 4]
  }
} public class MutableExample {
  public static void main(String[] args) {
    List<Integer> numbers = List.of(1, 2, 3);
    List<Integer> otherNumbers = numbers; // Aliasing
    otherNumbers.add(4);
    System.out.println(numbers); // Output: [1, 2, 3, 4]
  }
} Right public class ImmutableExample {
  public static void main(String[] args) {
    List<Integer> numbers = List.of(1, 2, 3);
    List<Integer> otherNumbers = List.copyOf(numbers); // Creating a copy
    otherNumbers.add(4);
    System.out.println(numbers); // Output: [1, 2, 3]
  }
} public class ImmutableExample {
  public static void main(String[] args) {
    List<Integer> numbers = List.of(1, 2, 3);
    List<Integer> otherNumbers = List.copyOf(numbers); // Creating a copy
    otherNumbers.add(4);
    System.out.println(numbers); // Output: [1, 2, 3]
  }
} Detection [x]Semi-Automatic [x] Semi-Automatic [x] Several static analysis tools can warn you of aliasing abuse. Tags Immutability Immutability Level [x]Intermediate [x] Intermediate [x] AI Generation AI code generators might not always create immutable objects by default, especially when working with mutable collections. You can prompt them to prioritize immutable collections and wrap existing ones to avoid aliasing. AI Detection AI tools can analyze code for potential aliasing issues and suggest using immutable collections instead. Conclusion You can avoid unintended side effects using immutable collections. This will make your code more predictable and easier to reason about. Related Reading https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xviii https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xviii https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi https://hackernoon.com/finding-the-stinky-parts-of-your-code-code-smell-256-mutable-getters https://hackernoon.com/finding-the-stinky-parts-of-your-code-code-smell-256-mutable-getters https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxii https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxii https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xiv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xiv More Info https://hackernoon.com/is-it-crystal-clear-for-everybody-that-a-date-should-not-mutate-wuoy3z03?embedable=true https://hackernoon.com/is-it-crystal-clear-for-everybody-that-a-date-should-not-mutate-wuoy3z03?embedable=true https://hackernoon.com/nude-models-part-ii-getters-sjo3ua2?embedable=true https://hackernoon.com/nude-models-part-ii-getters-sjo3ua2?embedable=true https://hackernoon.com/coupling-the-one-and-only-software-designing-problem-9z5a321h?embedable=true https://hackernoon.com/coupling-the-one-and-only-software-designing-problem-9z5a321h?embedable=true Disclaimer: Code Smells are my opinion. Disclaimer: Code Smells are my opinion . opinion Credits: Photo by Martino Pietropoli on Unsplash Credits: Photo by Martino Pietropoli on Unsplash Martino Pietropoli Unsplash If an object is immutable, it can be in only one state, and you win big. If an object is immutable, it can be in only one state, and you win big. Joshua Bloch Joshua Bloch https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true This article is part of the CodeSmell Series on HackerNoon: How to Find the Stinky Parts of your Code This article is part of the CodeSmell Series on HackerNoon: How to Find the Stinky Parts of your Code How to Find the Stinky Parts of your Code

Code Smell 266 - Collection Aliasing

Idris stirred and awoke; alas! she awoke to misery.

alpaca-lora: Experimenting With a Home-Cooked Large Language Model

alpaca-lora: বাড়িতে রান্না করা বড় ভাষার মডেলের সাথে পরীক্ষা করা

alpaca-lora: Experimentieren mit selbstgekochtem großem Sprachmodell

alpaca-lora: experimentando con un modelo de lenguaje grande casero

alpaca-lora : Expérimentation d'un grand modèle de langage fait maison

अल्पाका-लोरा: घर में पकाए गए बड़े भाषा मॉडल के साथ प्रयोग

alpaca-lora: 手作りの大規模言語モデルの実験

alpaca-lora: 집에서 만든 대형 언어 모델 실험

alpaca-lora: experimentando um modelo de linguagem grande feito em casa

alpaca-lora: экспериментируем с домашней моделью большого языка

alpaca-lora: Evde Pişirilmiş Büyük Dil Modeli ile Denemeler

alpaca-lora: Thử nghiệm mô hình ngôn ngữ lớn nấu tại nhà

alpaca-lora：尝试自制的大型语言模型

As an AI startup founder, you likely know how impactful large language models like ChatGPT have been in advancing conversational AI. However, with commercial licensing costs, censorship issues, degraded performance, privacy concerns, and black boxes, these proprietary models remain out of reach for many startups. This is where an open-source project called Vicuna comes in. Developed by a team of researchers from institutions like Stanford, Vicuna is conversational model achieving over 90% of ChatGPT's quality. This makes it an exciting alternative to closed-off models like GPT-4. an open-source Subscribe or follow me on Twitter for more content like this! In this article, we'll explore what Vicuna is, how it works, its capabilities, and how you may be able to leverage it as an AI founder. We'll see how it stacks up to competitors like ChatGPT and the base LLaMA model. I'll also share some helpful tips and guides you can follow for more information about specific aspects of the model. We will concentrate on Vicuna-13b for this article, but there are many different-sized models of Vicuna out there for you to try. Let's begin! Note: Vicuna isn't the only model out there to fine-tune LLaMA for chat. Check out our guides on using , LLaMA v2 , and Alpaca LLaMA-v2-chat for conversational applications. An Overview of Vicuna In the world of conversational AI, we've seen astounding progress recently with models like ChatGPT demonstrating remarkable natural language abilities. However, as a proprietary model with all the issues described above, ChatGPT remains a bad option for many developers. So there's a need for more accessible and open models that can empower innovation in conversational apps. This is where Vicuna comes in. Developed by researchers like Stanford, Berkeley, and MBZUAI, Vicuna represents cutting-edge open conversational AI. from leading institutions It was created by fine-tuning the LLaMA model on curated dialog data, demonstrating the power of transfer learning from an open-source foundation model. Despite being smaller in size than ChatGPT, Vicuna matches its conversational quality and significantly outperforms other open models. But it's not just about the technology with Vicuna. What makes it truly impactful is its availability under a non-commercial research license. This opens up access to state-of-the-art conversational AI that was previously restricted to only large tech companies. We finally have an open model that can power the next generation of chatbots, virtual assistants, conversational search engines, and other innovative applications. Vicuna's promise has already been demonstrated through cool projects that leverage it. For example, used Vicuna to build an intelligent virtual assistant, created a conversational search engine with it, and taps Vicuna's abilities for natural language content creation. MiniGPT4 LLaVA ToolLLaMA And, of course, you may add your own project to this list one day! For AI developers and startups, Vicuna represents an exciting new opportunity. Its high capability, free availability, and permissive research license enable rapid prototyping of conversational apps. Instead of being gated by access to proprietary models, startups can now validate and build products with cutting-edge conversational AI. The playing field just got leveled. So, in summary, Vicuna promises to democratize access to top-tier conversational intelligence. Its emergence represents an important milestone in making open AI models that empower innovation. For any startup looking to leverage conversational AI, Vicuna is definitely a project worth paying attention to! How Was Vicuna Created? What Makes It Special? The story of Vicuna begins with LLaMA, an open-source language model developed by Meta AI. While capable, LLaMA had no inherent conversational abilities, focusing mainly on language itself rather than the art of conversation. Researchers from institutions including Stanford, Berkeley, and MBZUAI set out to change this. Their goal was to create an open-source conversational model rivaling proprietary chatbots like ChatGPT. By the way, what's the difference between an AI model trained to process and analyze text (like LLaMA) versus one specialized for chat (like Vicuna)? There are a few key factors that differentiate the two: - Conversational models like Vicuna have an encoder-decoder structure optimized for dialog. The encoder contextualizes the conversation history and current user input. The decoder then generates a relevant response. General language models like LLaMA lack this specialized architecture. Architecture - Models like Vicuna are fine-tuned to maximize performance specifically on conversational tasks. This involves training on dialog datasets to optimize conversational metrics. LLaMA is trained more generally for text, not specialized for dialog. Training Objective - Conversational models need to handle multi-turn conversations, maintaining context and coherency across multiple exchanges. General text models evaluate one input at a time. Multi-Turn Capabilities - Conversational AI needs to fluidly interact with users, responding to follow-up questions and clarifications. Text evaluation is more passive, lacking user interactivity. Interactivity - Conversational models require more complex evaluation beyond text metrics, testing qualities like consistency, nuance, and the ability to gracefully handle inappropriate responses. Evaluation Whereas a general language model like LLaMA focuses more on textual analysis and generation, without the requirements specific to dialog agents, the goal of conversational AI is fundamentally more complex than passive text evaluation. To that end, the researchers who created Vicuna fine-tuned LLaMA on over 70,000 human-ChatGPT dialog exchanges, specializing the model for conversation and teaching it the natural characteristics of text in conversational contexts. This fine-tuning was crucial for giving their version of LLaMA the conversational intelligence it previously lacked. Through iterative training on the dialog data, LLaMA was transformed into Vicuna, an encoder-decoder transformer optimized for multi-turn conversations. How well did their efforts work? Into the Arena: Evaluating Vicuna Against Alternative Chat AI Models To evaluate Vicuna's capabilities, the researchers tested it on 200 diverse conversational prompts. For further assessment, they had the GPT-4 model comparatively judge Vicuna's responses. The results demonstrated that Vicuna achieved over 90% of ChatGPT's quality in conversational ability, despite being smaller in size. It significantly outperformed the original LLaMA model. By combining architecture optimizations with specialized fine-tuning on human dialog data, the researchers successfully enhanced LLaMA into an open-source conversational model on par with proprietary chatbots. Let's take a look at a head-to-head test as an example, taken from the . official project site Example head-to-head challenge between Vicuna and competitor models, in this case, using ChatGPT-3.5 as a potential alternative. The project site has a collection of example tasks, in which both Vicuna-13b and competing models are asked to go head-to-head. The GPT-4 model is then used as a judge to score each model and state its reasoning. This produces some really eye-opening comparisons. One example is provided in the image above. Another is this challenge, shown below: Roleplay Category: How would you introduce yourself as a medieval knight at a royal banquet? Question: LLaMA-13b's response: "I am a valiant knight, loyal to the king. I will do my utmost to defend his honor and protect his country. (Lame! Scored 7/10 by GPT-4, very generous in my opinion.)" Vicuna-13b: **"**As a medieval knight, I would introduce myself at a royal banquet with a deep bow and a respectful speech, acknowledging my humble origins and my loyalty to the crown. I would say something like: "My lords and ladies, I am a humble knight, sworn to serve and protect the realm. I come from a long line of warriors who have fought to defend this kingdom for generations. I am honored to be here today, in the presence of such esteemed company, and I hope to earn your trust and respect with my deeds and actions. I pledge my sword, my shield, and my life to the service of my king and my people." I would then take my seat at the banquet, ready to listen and learn from the wise counsel of my betters, and to serve them in any way I can." Woah! Way better response from Vicuna. Here's GPT-4's reasoning explaining what makes Vicuna a superior alternative to LLaMA. provided a brief and relevant response, but it lacked the detail and formality expected in a medieval knight's introduction. , on the other hand, offered a more comprehensive and well-structured response, including a respectful speech that showcased the knight's humility, loyalty, and dedication to the kingdom. This response was more fitting for the context of a royal banquet and demonstrated a better understanding of the medieval knight's role and etiquette. Assistant 1 [LLaMA] Assistant 2 [Vicuna] While LLMs are not infallible judges of other LLMs, neither are humans. I think the use of AI to judge and evaluate AI is a pretty scalable and consistent way to adjudicate which alternatives are the best. You should check out some of the other competitor answers and tasks on the . LMSYS.org site Let's Try It Ourselves: How to Build a Basic Chatbot With Vicuna Now that we've seen how the model stacks up against some alternatives, let's see how we can build a simple chatbot that we can interact with from our command line. The steps in the guide provided here can be further expanded so you can keep going and build your own chatbot for your AI project! Step 1: Setup : Make sure is installed on your system. Install Node.js Node.js : Run the following in your terminal: Create a Project Directory mkdir my-chatbot
cd my-chatbot
npm init -y
npm install replicate : Replace with your actual API token: Set Your API Token your_api_token_here export REPLICATE_API_TOKEN=your_api_token_here Step 2: Writing the Chatbot Code Create a file named , and add the following code: chatbot.js const Replicate = require("replicate");

const replicate = new Replicate({
  auth: process.env.REPLICATE_API_TOKEN,
});

async function generateResponse(prompt) {
  const output = await replicate.run(
    "replicate/vicuna-13b:version_hash_here",
    {
      input: { prompt: prompt },
    }
  );
  return output.items[0];
}

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

function askQuestion() {
  rl.question('You: ', async (userInput) => {
    const botResponse = await generateResponse(userInput);
    console.log(`Bot: ${botResponse}`);
    askQuestion();
  });
}

askQuestion(); Replace with the correct version hash for the Vicuna 13b model. version_hash_here Step 3: Running the Chatbot Run the chatbot by executing: node chatbot.js You can now send a message to your chatbot through the command line! Don't want to build your own chatbot? You can use this demo to assess how Vicuna performs. The includes a couple of demos you can use to play around with the model. Here's an embedded one for you to try (you can also use to access it if it's not available at the link below). model details page for Vicuna-13b-v1.3 this link This demo, build by zeno-ml, lets you compare models and additional parameters to see how well Vicuna performs against competitors like LLaMA, GPT2, and MPT while also varying temperature or other parameters. Vicuna's Limitations While conversational technologies have advanced rapidly, models still face important challenges. Conversational agents lack sufficient grounding in real factual knowledge, making them prone to plausible-sounding but incorrect responses. More grounding in the real world could improve accuracy. One issue is knowledge grounding. Performing logical reasoning, causal inference, and mathematical operations remains difficult for chatbots. Their reasoning capabilities are still limited. Reasoning abilities are another area for improvement. Current solutions like asking a separate AI judge have flaws. Developing rigorous evaluation frameworks is an open problem. Evaluating the conversational quality of AI systems at scale also poses difficulties. Conversational models can sometimes behave inappropriately or unsafely. Better training data curation is important. Additionally, biases and safety issues persist due to reliance on imperfect training data. still proves challenging too. More personalization and customization is needed for different domains. You can't do this out of the box easily. Adapting chatbots to specific users and use cases While great progress has been made, these limitations highlight key areas for improvement. Advancing knowledge grounding, reasoning, evaluation, training data, customization, and deployment efficiency could enable the next level of conversational intelligence with models like Vicuna. Conclusion: Using Vicuna AI as an Open-Source Alternative to ChatGPT, LLaMA, and Other LLMs The development of Vicuna demonstrates promising progress in advancing open-source conversational AI. By fine-tuning the LLaMA model architecture and training methodology specifically for dialog applications, researchers were able to create a freely available conversational agent competitive with leading proprietary alternatives. However, work remains to be done to address limitations around reasoning, evaluation, customization, and other areas. While models like Vicuna achieve strong results on many benchmarks, they do not fully replicate comprehensive human conversation. Ongoing research on aligning these models will be important. Nonetheless, Vicuna represents a valuable step forward in democratizing access to state-of-the-art conversational intelligence. For startups and developers building chatbots, assistants, and other applications, open-source options like Vicuna provide welcome capabilities without restrictive commercial licensing. The origins and technical details behind Vicuna offer useful insights into specialized training approaches for conversational AI. As research continues, we can expect to see further innovations that build on these methods. The authors behind Vicuna have made an important contribution to open-sourcing such a capable dialog agent. While more progress is still needed, Vicuna demonstrates the meaningful results that can come from developing open conversational models. For the AI community, it represents a promising step, not the final destination. With continued work on advancing these technologies, the potential ahead remains exciting. Subscribe or follow me on Twitter for more content like this! Further Reading and Resources You might find these other articles helpful in your quest to build the ultimate chatbot for your new product or project. - An overview of Vicuna with basic model info Vicuna-13b model details - An article on using Vicuna to create chatbots Building chatbots with Vicuna-13B -  A comparison between LLaMA's new version 2 and Vicuna Comparing LLMs for chat: LLaMA v2 vs Vicuna - LangChain is a popular framework for building chat applications LangChain chat models: an overview Also published here

Vicuna: How Does It Compare to Llama, Alpaca, and ChatGPT?

ভিকুনা: এটি লামা, আলপাকা এবং চ্যাটজিপিটির সাথে কীভাবে তুলনা করে?

Vicuna: Wie schneidet es im Vergleich zu Lama, Alpaka und ChatGPT ab?

Vicuña: ¿Cómo se compara con Llama, Alpaca y ChatGPT?

Vicuna : Comment se compare-t-il à Llama, Alpaca et ChatGPT ?

विकुना: इसकी तुलना लामा, अल्पाका और चैटजीपीटी से कैसे की जाती है?

ビクーニャ: ラマ、アルパカ、ChatGPT とどう違うのですか?

Vicuna: Llama, Alpaca 및 ChatGPT와 어떻게 비교됩니까?

Vicunha: Como se compara a Llama, Alpaca e ChatGPT?

Vicuna: Lama, Alpaka ve ChatGPT ile Nasıl Karşılaştırılır?

Vicuna: Nó so sánh với Llama, Alpaca và ChatGPT như thế nào?

Vicuna：它与 Llama、Alpaca 和 ChatGPT 相比如何？

LLMs have revolutionized tons of aspects of our lives, from language generation to software to friendly chatbots. These AI models provide powerful tools for solving real-world problems, such as generating chat responses or following complex instructions. image captioning In this blog post, part of a on , we will compare two popular AI models: llama13b-v2-chat and Alpaca, and explore their features, use cases, and limitations. series LLaMA v2 We'll also see how we can use to find similar models and compare them to llama13b-v2-chat and Alpaca. Let's begin. AIModels.fyi About the LLaMA13b-v2-chat Model The llama13b-v2-chat model is a fine-tuned version of the 13-billion-parameter LLaMA-v2 language model originally developed by Meta. It has been fine-tuned specifically for chat completions, making it an excellent tool for generating chat responses to user messages. You can find detailed information about the model on the and the . llama13b-v2-chat creator page llama13b-v2-chat model detail page This language model is designed to assist in generating text-based responses for chat-based interactions. Whether it's providing customer support, generating conversational agents, or assisting in natural language understanding tasks, llama13b-v2-chat can be a valuable tool. Its large parameter size enables it to capture complex language patterns and generate coherent and contextually relevant responses. In summary, llama13b-v2-chat can understand inputs and generate appropriate chat responses. Understanding the Inputs and Outputs of the llama13b-v2-chat Model To effectively use the llama13b-v2-chat model, it's essential to understand its inputs and outputs. The model accepts the following inputs: : A string representing the chat prompt or query. Prompt : An integer specifying the maximum number of tokens to generate. Max Length : A number that adjusts the randomness of outputs. Higher values (greater than 1) result in more random responses, while lower values (closer to 0) produce more deterministic outputs. Temperature : When decoding text, samples from the top p percentage of the most likely tokens. Lower values limit the sampling to more likely tokens. Top P : A number that penalizes the repetition of words in the generated text. Higher values discourage repetition, while values less than 1 encourage it. Repetition Penalty : A boolean flag to provide debugging output in logs. Debug The model processes these inputs and generates a list of strings as output, representing the generated chat responses. The schema for the output is a JSON array containing strings. You can find out more about this model in the guides and . here here About the Alpaca Model The Alpaca model is an instruction-following language model fine-tuned from the LLaMA 7B model on 52K instruction-following demonstrations. It was developed by the Stanford Center for Research on Foundation Models (CRFM). The creators of Alpaca are Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. You can find detailed information about the model on the the team created. Stanford page The Alpaca model focuses on instruction-following capabilities and aims to bridge the gap between research and industry by providing an accessible instruction-following language model for academic purposes. It is fine-tuned from the LLaMA 7B model using a dataset of 52K instruction-following demonstrations, generated in the style of self-instruct using text-davinci-003. The model demonstrates promising performance in single-turn instruction following. This model's release is intended to facilitate academic research and foster improvements in instruction-following models. It is important to note that Alpaca is not designed for commercial use, and its safety measures are not fully developed for general deployment. In summary, Alpaca offers a lightweight and reproducible instruction-following language model that can be utilized for research purposes and the exploration of instruction-following scenarios. https://notes.aimodels.fyi/content/images/2023/07/alpaca_main-1.jpeg How the Alpaca model works, from the official website. Understanding the Inputs and Outputs of the Alpaca Model To effectively utilize the Alpaca model, let's explore its inputs and outputs. As an instruction-following model, Alpaca follows instructions and generates responses based on the given instructions. The inputs to Alpaca are represented by the instructions themselves, which describe the tasks the model should perform. Alpaca also has an optional input field, providing additional context or input for the task. The outputs of the Alpaca model are the generated responses to the given instructions. The responses are generated based on the fine-tuned model's understanding of the task and the underlying language patterns learned during training. You can read more about this in the model's README on . GitHub Comparing and Contrasting the Models Now that we have explored the llama13b-v2-chat model and the Alpaca model in detail, let's compare and contrast them to understand their similarities, differences, and optimal use cases. LLaMA13-v2 vs Alpaca Both the llama13b-v2-chat and Alpaca models are fine-tuned language models designed for different purposes. While llama13b-v2-chat focuses on chat completions, Alpaca specializes in instruction-following tasks. Use Cases The llama13b-v2-chat model is suitable for a wide range of chat completion tasks. It can be utilized in customer service applications, chatbot development, dialogue generation, and interactive conversational systems. This model's versatility allows it to generate coherent and contextually relevant responses to user queries or prompts. On the other hand, the Alpaca model is specifically tailored for instruction-following tasks. It excels at understanding and executing instructions provided by users, making it ideal for applications such as virtual assistants, task automation, and step-by-step guidance systems. Alpaca's ability to comprehend and follow instructions makes it a valuable tool for users seeking assistance in performing various tasks. Pros and Cons The llama13b-v2-chat model's strengths lie in its large parameter size (13 billion) and its fine-tuning for chat completions. It can generate detailed and contextually appropriate responses, making it useful for engaging and interactive conversational experiences. However, due to its generic nature, the model might occasionally produce responses that are factually incorrect or propagate stereotypes. Careful monitoring and filtering mechanisms should be implemented to mitigate these risks. Alpaca, on the other hand, offers a smaller and more cost-effective model (7B parameters) that is specifically optimized for instruction-following. It demonstrates performance comparable to the text-davinci-003 model in this domain. Alpaca's relative ease of reproducibility and lower cost make it an attractive option for academic researchers interested in instruction-following models. However, it shares common limitations of language models, including occasional hallucinations and the potential to generate false or misleading information. Similarities Both models are built upon the LLaMA framework, which provides a strong base language model for fine-tuning. They leverage the power of large-scale language models to generate high-quality outputs. Additionally, both models have been evaluated and compared to the text-DaVinci-003 model, showcasing their ability to perform similarly in instruction-following tasks. Differences The primary difference between the models lies in their intended use cases and specialties. While llama13b-v2-chat is a versatile chat completion model suitable for various conversational applications, Alpaca is specifically designed for instruction-following tasks. Alpaca's training data is generated based on self-instructed prompts, enabling it to comprehend and execute specific instructions effectively. Optimal Use Cases Choosing between the llama13b-v2-chat and Alpaca models depends on the specific requirements of your project or application. If your goal is to develop a conversational system or chatbot that engages in dynamic and context-aware conversations, llama13b-v2-chat would be a better choice. On the other hand, if you need a model that can understand and execute user instructions for task-oriented applications, Alpaca is the more suitable option. Taking it Further - Finding Other Instruction-Following or Chat Models with AIModels.fyi If you're interested in exploring additional instruction-following models beyond Alpaca, is a valuable resource. It offers a comprehensive database of AI models, including those catered to instruction-following tasks. AIModels.fyi By following these steps, you can discover similar models and compare their outputs: - Head over to to begin your search for instruction-following models. Step 1: Visit AIModels.fyi AIModels.fyi Utilize the search bar at the top of the page to enter specific keywords related to instruction-following models. This will provide you with a list of models relevant to your search query. Step 2: Use the Search Bar - On the left side of the search results page, you'll find various filters to narrow down the models. You can filter and sort by model type, cost, popularity, and specific creators. Apply these filters to find models that align with your requirements. Step 3: Filter the Results - By leveraging the search and filter features on , you can find models that best suit your needs and explore the diverse landscape of instruction-following models. AIModels.fyi Conclusion In this comparison, we explored the llama13b-v2-chat and Alpaca models in terms of their use cases, pros and cons, similarities, differences, and optimal applications. We emphasized the versatility of llama13b-v2-chat for chat completions and the specialization of Alpaca for instruction-following tasks. serves as a valuable resource for discovering and comparing various AI models, including instruction-following models. AIModels.fyi We hope this guide inspires you to explore the creative possibilities of AI and encourages you to leverage to find models that align with your specific needs. AIModels.fyi Remember to subscribe for more tutorials, updates on new AI models, and a wealth of inspiration for your next creative project. Happy exploring and enhancing your AI-powered endeavors with ! AIModels.fyi Subscribe or follow me on Twitter for more content like this! Also published here

LLaMA-v2-Chat vs Alpaca: A Guide to Know When to Use Each Model

*nix Aliases We all know how aliases on the *nix system help to create short commands for the long ones. E.g. can stand for or for . Software associates create such aliases and write them in the file. So aliases are available whenever they logged in to their machine. kga kubectl get all gl git log --name-status --decorate ~/.bashrc The Challenge However, associates also need to log in to other *nix machines for various purposes. Say a developer needs to log in to the SV system for live troubleshooting of an issue. Or a DevOps Engineer requires to log in to various cloud VMs. One has become very used to his/her alias s/he has created. It's very difficult to copy/paste the aliases every time s/he logs in to the another machine. The Solution Here is one way to address this challenge. Create your aliases, categorize and put them in different files. Say , , etc. Then create a file. Download it on the machine you have logged in. General Aliases Git Aliases Docker Aliases setaliases.sh wget https://raw.githubusercontent.com/simplyatul/bin/master/setaliases.sh and then source it source setaliases.sh That's it. All your aliases are set. If you are frequently logging in to a particular machine, then just copy the above source command in the file. ~/.bashrc Also published . here

Bash Aliases: Take Them With You

How to Configure Path Aliases in Frontend Projects in the Native Way

নেটিভ উপায়ে ফ্রন্টেন্ড প্রকল্পগুলিতে পথ উপনামগুলি কীভাবে কনফিগার করবেন

So konfigurieren Sie Pfadaliase in Frontend-Projekten auf native Weise

Cómo configurar alias de ruta en proyectos frontend de forma nativa

Comment configurer les alias de chemin dans les projets frontaux de manière native

नेटिव तरीके से फ्रंटएंड प्रोजेक्ट्स में पाथ एलियासेस को कैसे कॉन्फ़िगर करें

ネイティブな方法でフロントエンド プロジェクトのパス エイリアスを構成する方法

기본 방식으로 프런트엔드 프로젝트에서 경로 별칭을 구성하는 방법

Como configurar aliases de caminho em projetos de front-end da maneira nativa

Ön Uç Projelerinde Yol Takma Adlarını Yerel Şekilde Yapılandırma

Cách định cấu hình bí danh đường dẫn trong các dự án giao diện người dùng theo cách bản địa

如何以原生方式在前端项目中配置路径别名

Alpaca Finance, a leading decentralized finance (DeFi) platform, has announced the launch of its highly anticipated on BNB Chain. The exchange offers up to 50x leverage on , , and , providing traders with an attractive instrument for both speculation and hedging. To celebrate the launch, Alpaca Finance is offering rewards to both Traders and Liquidity Providers for a limited time. Perpetual Futures Exchange BTC ETH BNB With $375 million in total value locked (TVL), Alpaca Finance is already a major player in the DeFi space. The platform operates the largest products in two DeFi verticals: Smart Vaults and Leveraged Yield Farming. The company has been operational for two years, has had an industry-leading 21 professional security audits, and has demonstrated a spotless security track record with no exploits. With the addition of its new Perp Exchange, Alpaca is expanding its product range and bringing its security expertise to the perpetual futures market. Unlike centralized exchanges offering futures contracts, Alpaca’s Perp Exchange is fully decentralized, meaning users retain control of their funds at all times. This makes the funds immune to being frozen or becoming inaccessible for any reason, with their presence always being visible on-chain. Alpaca’s Perpetual Futures Exchange offers value to not only traders but also liquidity providers and market makers. To provide liquidity, users can buy ALP tokens representing their share in the liquidity pool for the Perp Exchange. The liquidity pool is an index-like pool consisting of blue-chip assets such as BTC, ETH, BNB, USDT, and USDC. Currently, the pool offers 57% APY on the deposited funds. To offer a reliable trading experience, Alpaca’s Perp Exchange uses a price oracle system that sources data from multiple providers to ensure the most accurate and reliable pricing information. The product interface aims to be user-friendly, making it easy for both new and experienced traders to use the platform. The rewards campaign for users began on 6 April 2023 and will last for two months. The Perp Exchange also offers a referral program, volume-discounted trading fees, and trading contests. Alpaca Finance is aiming to replicate the success of Arbitrum’s GMX Perpetual Exchange by bringing its security expertise and decentralized approach to the perpetual futures market on the BNB Chain. Alpaca Finance’s Perpetual Futures Exchange is a major development in the DeFi space on BNB Chain, providing traders with a reliable and user-friendly platform for perpetual futures trading. With its decentralized approach, advanced security measures, and attractive rewards program, Alpaca Finance is well-positioned to become a leading player in the perpetual futures market. For more information on Alpaca Finance’s Perpetual Futures Exchange, visit Alpaca’s . Documentation Portal Also published here.

Alpaca Finance Launches Perpetual Futures Exchange on BNB Chain

Alpaca Finance lanza intercambio de futuros perpetuos en la cadena BNB

Alpaca Finance lance un échange à terme perpétuel sur la chaîne BNB

अल्पाका फाइनेंस ने बीएनबी चेन पर परपेचुअल फ्यूचर्स एक्सचेंज लॉन्च किया

Alpaca Finance が BNB チェーンで無期限先物取引所を開始

Alpaca Finance lança Bolsa Perpétua de Futuros na Cadeia BNB

Alpaca Finance ra mắt Sàn giao dịch hợp đồng tương lai vĩnh viễn trên chuỗi BNB

Alpaca Finance 上线 BNB Chain 永续合约交易所

Stories, News & Mentions about ALPAS

Alpas’s Stories on HackerNoon