Get the most recent info and news about Loc8 on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

Easily manage your Field service jobs, schedules, assets, quotes and invoices with our field service management software for small business.

Loc8

loc8

The auction raised approximately NAD28.6 million (USD1.47 million), with mobile providers MTC (Mobile Telecommunications Company) and TN (Telecom Namibia) procuring licences alongside local ISP Loc8 Mobile. Each obtained one of the three available lots ...

MTC, Telecom Namibia and Loc8 Mobile bag 5G licences at auction

What Are the Top Startups in Oceania?

In these story series I am going to cover specific parts of the Angular application which are not obvious to implement with the NgRx library. Angular NgRX is powered state for Angular applications, inspired by . It helps us to manage a state of the application, and there are some benefits over the standard service-oriented approach. NgRx RxJS management Redux Short Story If you are lazy to read a step-by-step explanation, check for the full implementation. Github repo example Problem We are writing an Angular app with the NgRX approach. We want to be sure that before we can enter to page we have data to show in this component. You can check the standard implementation of the . And we will go forward to understand how to achieve that with the NgRX State management. Profile Route Resolver from official docs Pre-conditions Let’s take a look at It’s a classical subscription to Observable been returned by network call from No matter what’s for is using this data, let’s assume we need to be sure data exists before we enter the component. ProfileComponent . ApiService . ProfileComponent Defining Reducer and Actions My personal preferences to keep files in feature oriented structure. So we will place new files to the same folder as our were placed. Here is a new structure of folder after we’ve created and . ProfileComponent profile.reducer.ts profile.actions.ts Profile folder structure profile.component.ts profile.component.html profile.actions.ts profile.reducer.ts Taking a look at profile.actions.ts — list of actions which we will use to manipulate data related to Profile entity. In case want to extend functionality, we can add such actions as , etc. For now, we are fine with action which will trigger for updating of the Profile data. IProfileActions PORFILE_INIT PROFILE_CHANGE — is single action type which we define to describe an action of getting new data ( type). UpdateAction IProfileData Now let's handle this action in the profile.reducer.ts — to describe how are we going to extend basic reducer of application. IProfileState — default value for initialState ProfileData — processes single action (UPDATE) to describe state changes after the action was triggered with some payload reducer Extending root reducer We compose root state of the application by adding reducer to all (LOC: 11 ). Object reducers app.state.ts And the last thing — we defining the StoreModule with the reducers we’ve created before (LOC: 8 ). storeReducers app.module.ts Setting up route resolver Now, let’s put resolver on the route we want to wait until data will be loaded. Continue by creating with the corresponding class as we name it on the LOC: 8 in above. This line is saying to wait for navigation to route until data will be resolved in the which we are going to implement in a second. profile.resolver.ts app.routes.ts /profile ProfileResolver A newly created class implementing interface which obliges us to define function. This function can return , or expected type directly. [Resolve](https://angular.io/api/router/Resolve) _resolve_ Promise Observable : Function **waitForProfileDataToLoad** Subscribe store to listen for object changes. LOC 23: profile Map values to get the only from the general object LOC 24: profileData profile Ignore all triggers where does not exist LOC 25: profileData take(1) — getting only first value, as long as we need single one to resolve route LOC 26: : Function **initProfileData** Getting the first value of object located in the store. If there is no value: profile Get data by using getProfileData() Convert it to (we need only once, so no point for subscribing to Observable) Promise And dispatch with the which we just got from server UpdateAction data Route resolver conclusion We’ve initialized data by getting it from the server, and dispatching new state for the application store. Meanwhile, we told our function to listen for the store changes, and return with the first nonempty it will find in the store. resolve Observable ProfileData Using route data in component Finally, we are getting from route snapshot, assuming it exist there. profileData must Conclusion NgRx driven applications make very clear a data flow process through the application. I hope that will give you some patterns how to solve route resolving problem. Here are few things you can also do to improve your application experience: could be moved or removed if you have some different places to init data. **initProfileData** — You can implement spinner to show while route resolvers are in action. There is some basic implementation in the . full repo example Your component could be subscribed to store directly if you expect data to be changed from another place. In such case, you can convert to return instead of data. Could be nice homework exercise to master this topic 😜. ProfileResolver Boolean Github repo example Thanks for reading! If you want me to write more similar stories recommend this post (by clicking the ❤ button). Write your thoughts to comments and subscribe to my to find more stories. medium

Angular NgRx: Resolving Route Data

AI-Powered Localization Using an Open-source Project as a Case Study

How to Run Your Own Local LLMs: Updated for 2024 with 15 Local LLM Open Source Tools!

Hi! My name’s Amir. I’m a Web3 Community Manager and a podcast host. To improve the reach of my podcast, 2 months ago, I tried the Rask.ai platform, and have edited over 10 hours of footage since. In this review, I’ll go into the challenges Rask.ai can solve for you, its features, and the pros/cons of the platform. What Is Rask.ai, and Why Did I Buy It? Essentially, Rask.ai is a platform that uses AI for video/audio localization and repurposing. By repurposing, I mean auto reframing to vertical format, and auto-editing long videos to capture the most interesting moments. Rask.ai poses itself as a platform that has all the AI features for content makers in one place, a one-stop-shop of some sort. In one subscription, you get all the AI tools you would need to make your video content better. The main purpose that I had in mind when checking out Rask.ai was to increase the reach of my podcast on TikTok and YouTube. The podcast originally is in Kazakh, but to expand the potential audience and potential advertisers, I was looking for ways to target the English-speaking market as well. Price, Interface, and Functionality The platform is very flexible when it comes to pricing: you have 3 options to choose from, which vary by the price, the amount of minutes, and other available features. Honestly, I think the only metric you should really look at is the amount of minutes, as it will influence your work the most. I’ve picked the second plan, Creator Pro. It includes 100 minutes of edited footage per month and costs me $120. They also offer a plan for $50 and 25 minutes, as well as a corporate plan - $600 and 500 minutes. The biggest plan the platform offers is enterprise, which starts at 2000 minutes with a custom price. Note that all prices are correct if you pay annually - plans with monthly payments will be ~15% more expensive. Last month, I had 2 podcasts instead of one, and I ran out of minutes on my regular plan. However, you can always buy additional minutes at a $3 rate. Setting up the account is very easy (as it should be in 2024): you can use your Google account to log in or create the account with your email. The interface is very clean and isn’t overloaded by different buttons and links. You have FAQ and customer support at the top right corner, accessible from any page, so if you get a bit confused, there’s always that. I can’t say that I’m a tech guru of any kind, but I got used to the website in a matter of minutes. I’ve never worked with a mobile version of the site as I always store all raw footage on my Mac, but if you’re editing a small TikTok/Reels, you can easily do it from your phone. What Does Rask.ai Do, and How Do I Use It? The platform has 2 main features: localization and shorts. Let’s start with the first one, which became a selling point for me. You download a video from your device or paste a link from YouTube or Google Drive, choose the number of speakers, original language, and the language you want to translate the video to, and click “translate.” After that, the magic begins. In a matter of minutes (depending on the length of the video), you get the same video but translated to a different language. The voice-over keeps the voice’s depth, tone, and emotion, and even creates a lip sync, so the video footage is similar to the audio. How do I use that feature? Before discovering Rask.ai, in order to reach the English-speaking market, I was adding EN subtitles to all my podcasts. However, that approach was far from ideal as I was always encountering many barriers: Time-consumption. The current speech-to-text AI solutions are very far from perfect. On 100 AI-generated subtitles, I was getting ~30 errors that I needed to edit manually. Scale that to hours of footage and thousands of text, and you get yourself many hours of manual work.


Accessibility. Subtitles can’t be a permanent solution to expand your foreign audience, especially when it comes to podcasts. When was the last time you paid attention to video footage on a podcast? People listen to them while exercising, cooking, cleaning, and working. My podcast gets 40% more listeners on Spotify and Google Podcasts (which don’t have video) vs YouTube (which has video), meaning that people aren’t looking at the screen and subtitles when listening.


Retention. Even if a person bothers to actively read the subtitles, they still are getting less than people watching the original. Many intonations, jokes, or facial expressions are just not working when perceptive through text. Listeners are too busy reading to actually relax and enjoy the podcast. The Rask.ai platform solved all these problems for me. The amount of manual work I had to do had decreased to practically 0, since in 2 months of using the platform, I haven’t encountered any errors in translations. The retention improved a lot as well: YouTube has statistics that show you how many people watch your videos until the end, and this number significantly improved, since your listeners can actually LISTEN instead of reading. Another feature that I didn’t even know about when getting the subscription to Rask.ai is Shorts. Basically, it takes your hour-long footage and splits the most interesting moments into many short vertical videos. As you probably know, one of the best ways to promote your podcast in 2024 is to share these videos on TikTok, Shorts, and Reels, because these platforms have much better recommendation systems than YouTube, and putting the link to the full podcast in your bio. That’s how I personally discovered many of my favorite podcasts and began to host them myself. Before discovering that feature, I had a friend on a part-time salary doing that for me, because apart from the podcast, I also have a full-time job in Web3 that is taking a significant part of my day. Creating 15 short videos from one podcast took us about 5-6 hours of manual work since you have to fully watch the podcast, then edit all shorts separately, and add some graphics and subtitles. When I discovered a shorts feature on Rask.ai, the same amount of work took me from 5 to 10 minutes (again, depending on the length of the footage). This let me cut my editorial costs down to the sole price of my Rask.ai plan, without having to pay the salary to a whole person doing that. And you say AI won’t take our jobs :) There are a couple of smaller features that I haven’t really tested a lot until today, but I’m planning on exploring them in the future as well. For example, subtitles generation, and API for translations. The company also plans on integrating some features that I’m really excited about: AI video generation (Like MidJourney, but videos), and Zapier integration. Pros, Cons, and Who Can Use It? In conclusion, Rask.ai won’t make your video content more interesting or helpful and won’t make you a superstar overnight. However, with the right distribution strategy and exciting content, Rask.ai will significantly cut your editorial costs, saving you hundreds of dollars on people who translate and edit your content for you, as well as save you A LOT of time, letting you focus on the stuff that really matters: scripts, topics, guests, and other things that make your content better. Rask.ai is a great solution for podcast hosts like myself, social media or community managers producing content for their companies, or TikTok and Instagram influencers that focus on short video content. Pros: Clean and simple interface
Precise translations
Multiple features in one subscription Cons: Relatively high prices
Not all features are ready yet Hi! My name’s Amir. I’m a Web3 Community Manager and a podcast host. To improve the reach of my podcast, 2 months ago, I tried the Rask.ai platform, and have edited over 10 hours of footage since. In this review, I’ll go into the challenges Rask.ai can solve for you, its features, and the pros/cons of the platform. What Is Rask.ai, and Why Did I Buy It? What Is Rask.ai, and Why Did I Buy It? Essentially, Rask.ai is a platform that uses AI for video/audio localization and repurposing. By repurposing, I mean auto reframing to vertical format, and auto-editing long videos to capture the most interesting moments. Rask.ai poses itself as a platform that has all the AI features for content makers in one place, a one-stop-shop of some sort. In one subscription, you get all the AI tools you would need to make your video content better. The main purpose that I had in mind when checking out Rask.ai was to increase the reach of my podcast on TikTok and YouTube. The podcast originally is in Kazakh, but to expand the potential audience and potential advertisers, I was looking for ways to target the English-speaking market as well. Price, Interface, and Functionality Price, Interface, and Functionality The platform is very flexible when it comes to pricing: you have 3 options to choose from, which vary by the price, the amount of minutes, and other available features. Honestly, I think the only metric you should really look at is the amount of minutes, as it will influence your work the most. I’ve picked the second plan, Creator Pro. It includes 100 minutes of edited footage per month and costs me $120. They also offer a plan for $50 and 25 minutes, as well as a corporate plan - $600 and 500 minutes. The biggest plan the platform offers is enterprise, which starts at 2000 minutes with a custom price. Note that all prices are correct if you pay annually - plans with monthly payments will be ~15% more expensive. Last month, I had 2 podcasts instead of one, and I ran out of minutes on my regular plan. However, you can always buy additional minutes at a $3 rate. Setting up the account is very easy (as it should be in 2024): you can use your Google account to log in or create the account with your email. The interface is very clean and isn’t overloaded by different buttons and links. You have FAQ and customer support at the top right corner, accessible from any page, so if you get a bit confused, there’s always that. I can’t say that I’m a tech guru of any kind, but I got used to the website in a matter of minutes. I’ve never worked with a mobile version of the site as I always store all raw footage on my Mac, but if you’re editing a small TikTok/Reels, you can easily do it from your phone. What Does Rask.ai Do, and How Do I Use It? What Does Rask.ai Do, and How Do I Use It? The platform has 2 main features: localization and shorts. Let’s start with the first one, which became a selling point for me. You download a video from your device or paste a link from YouTube or Google Drive, choose the number of speakers, original language, and the language you want to translate the video to, and click “translate.” After that, the magic begins. In a matter of minutes (depending on the length of the video), you get the same video but translated to a different language. The voice-over keeps the voice’s depth, tone, and emotion, and even creates a lip sync, so the video footage is similar to the audio. How do I use that feature? Before discovering Rask.ai, in order to reach the English-speaking market, I was adding EN subtitles to all my podcasts. However, that approach was far from ideal as I was always encountering many barriers: Time-consumption. The current speech-to-text AI solutions are very far from perfect. On 100 AI-generated subtitles, I was getting ~30 errors that I needed to edit manually. Scale that to hours of footage and thousands of text, and you get yourself many hours of manual work. Accessibility. Subtitles can’t be a permanent solution to expand your foreign audience, especially when it comes to podcasts. When was the last time you paid attention to video footage on a podcast? People listen to them while exercising, cooking, cleaning, and working. My podcast gets 40% more listeners on Spotify and Google Podcasts (which don’t have video) vs YouTube (which has video), meaning that people aren’t looking at the screen and subtitles when listening. Retention. Even if a person bothers to actively read the subtitles, they still are getting less than people watching the original. Many intonations, jokes, or facial expressions are just not working when perceptive through text. Listeners are too busy reading to actually relax and enjoy the podcast. Time-consumption. The current speech-to-text AI solutions are very far from perfect. On 100 AI-generated subtitles, I was getting ~30 errors that I needed to edit manually. Scale that to hours of footage and thousands of text, and you get yourself many hours of manual work. Time-consumption. The current speech-to-text AI solutions are very far from perfect. On 100 AI-generated subtitles, I was getting ~30 errors that I needed to edit manually. Scale that to hours of footage and thousands of text, and you get yourself many hours of manual work. Accessibility. Subtitles can’t be a permanent solution to expand your foreign audience, especially when it comes to podcasts. When was the last time you paid attention to video footage on a podcast? People listen to them while exercising, cooking, cleaning, and working. My podcast gets 40% more listeners on Spotify and Google Podcasts (which don’t have video) vs YouTube (which has video), meaning that people aren’t looking at the screen and subtitles when listening. Accessibility. Subtitles can’t be a permanent solution to expand your foreign audience, especially when it comes to podcasts. When was the last time you paid attention to video footage on a podcast? People listen to them while exercising, cooking, cleaning, and working. My podcast gets 40% more listeners on Spotify and Google Podcasts (which don’t have video) vs YouTube (which has video), meaning that people aren’t looking at the screen and subtitles when listening. Retention. Even if a person bothers to actively read the subtitles, they still are getting less than people watching the original. Many intonations, jokes, or facial expressions are just not working when perceptive through text. Listeners are too busy reading to actually relax and enjoy the podcast. Retention. Even if a person bothers to actively read the subtitles, they still are getting less than people watching the original. Many intonations, jokes, or facial expressions are just not working when perceptive through text. Listeners are too busy reading to actually relax and enjoy the podcast. The Rask.ai platform solved all these problems for me. The amount of manual work I had to do had decreased to practically 0, since in 2 months of using the platform, I haven’t encountered any errors in translations. The retention improved a lot as well: YouTube has statistics that show you how many people watch your videos until the end, and this number significantly improved, since your listeners can actually LISTEN instead of reading. Another feature that I didn’t even know about when getting the subscription to Rask.ai is Shorts. Basically, it takes your hour-long footage and splits the most interesting moments into many short vertical videos. As you probably know, one of the best ways to promote your podcast in 2024 is to share these videos on TikTok, Shorts, and Reels, because these platforms have much better recommendation systems than YouTube, and putting the link to the full podcast in your bio. That’s how I personally discovered many of my favorite podcasts and began to host them myself. Before discovering that feature, I had a friend on a part-time salary doing that for me, because apart from the podcast, I also have a full-time job in Web3 that is taking a significant part of my day. Creating 15 short videos from one podcast took us about 5-6 hours of manual work since you have to fully watch the podcast, then edit all shorts separately, and add some graphics and subtitles. When I discovered a shorts feature on Rask.ai, the same amount of work took me from 5 to 10 minutes (again, depending on the length of the footage). This let me cut my editorial costs down to the sole price of my Rask.ai plan, without having to pay the salary to a whole person doing that. And you say AI won’t take our jobs :) There are a couple of smaller features that I haven’t really tested a lot until today, but I’m planning on exploring them in the future as well. For example, subtitles generation, and API for translations. The company also plans on integrating some features that I’m really excited about: AI video generation (Like MidJourney, but videos), and Zapier integration. Pros, Cons, and Who Can Use It? Pros, Cons, and Who Can Use It? In conclusion, Rask.ai won’t make your video content more interesting or helpful and won’t make you a superstar overnight. However, with the right distribution strategy and exciting content, Rask.ai will significantly cut your editorial costs, saving you hundreds of dollars on people who translate and edit your content for you, as well as save you A LOT of time, letting you focus on the stuff that really matters: scripts, topics, guests, and other things that make your content better. Rask.ai is a great solution for podcast hosts like myself, social media or community managers producing content for their companies, or TikTok and Instagram influencers that focus on short video content. Pros: Pros: Clean and simple interface Precise translations Multiple features in one subscription Clean and simple interface Precise translations Multiple features in one subscription Cons: Cons: Relatively high prices Not all features are ready yet Relatively high prices Not all features are ready yet

How to Localize Your Shorts in 3 Clicks

Location, Location, Location! PostGIS and Heroku Postgres

অবস্থান, অবস্থান, অবস্থান! পোস্টজিআইএস এবং হেরোকু পোস্টগ্রেস

Lage, Lage, Lage! PostGIS und Heroku Postgres

¡Ubicación, ubicación, ubicación! PostGIS y Heroku Postgres

Emplacement, emplacement, emplacement ! PostGIS et Heroku Postgres

स्थान, स्थान, स्थान! PostGIS और Heroku Postgres

場所、場所、場所！PostGIS と Heroku Postgres

위치, 위치, 위치! PostGIS와 Heroku Postgres

Localização, localização, localização! PostGIS e Heroku Postgres

Местоположение, Расположение, Местоположение! PostGIS и Heroku Postgres

Konum, Konum, Konum! PostGIS ve Heroku Postgres

Vị trí, vị trí, vị trí! PostGIS và Heroku Postgres

位置，位置，位置！PostGIS 和 Heroku Postgres

Authors:
(1) Ankur Nath, Department of Computer Science and Engineering, Texas A&M University;
(2) Alan Kuhnle, Department of Computer Science and Engineering, Texas A&M University. Table of Links Abstract & Introduction Related work Evaluation for Max-Cut Evaluation for SAT Summary and Outlook, References Supplementary Materials 2 RELATED WORK As stated before, we will limit our discussion to local search heuristics. For future reference, we will specifically refer to local search heuristics when discussing heuristics. 2.1 Classical Heuristics In this subsection, we explore works that can solve diverse CO problems without polynomial time reduction. In their influential work, Khalil et al. (2017) introduced Structure-to-Vector GNN trained with Deep Q-Networks (DQN) to address various CO problems. The resulting S2V-DQN algorithm showcased strong performance across diverse CO problems by effectively generalizing across graphs of varying sizes and topologies. Building on the work of Khalil et al. (2017) , Manchanda et al. (2019) initially trained an embedding Graph Convolution Network (GCN) in a supervised manner. Subsequently, they trained a Qnetwork using reinforcement learning (RL) to predict action values for each vertex. Their method employed GCN embeddings to prune nodes unlikely to be part of the solution set, significantly enhancing scalability compared to S2V-DQN. However, it is not applicable to problems where nodes cannot be pruned, including fundamental CO problems like the Max-Cut problem. 2.2 Generalized Learned Heuristics Barrett et al. (2020) proposed ECO-DQN, a SOTA RL algorithm for Max-Cut. ECO-DQN improves the initial solution by navigating between the local optimal points. However, ECO-DQN uses a costly GNN at each decision step, resulting in worse scalability than S2V-DQN. To address scalability challenges in ECODQN, Barrett et al. (2022) proposed ECORD. This approach limited the costly GNN to a pre-processing step and introduced a recurrent unit for fast-action selection. 2.3 Learned Heuristics for SAT In the domain of Boolean Satisfiability, the application of machine learning to solving SAT problems is not a new idea (Battiti and Protasi, 1997; Haim and Walsh, 2009; Flint and Blaschko, 2012; Grozea and Popescu, 2014; Ganesh et al., 2009; Liang et al., 2016). In recent years, there has been a trend in integrating GNNs with SAT solvers(Yolcu and P´oczos, 2019; Lederman et al., 2019; Kurin et al., 2020; Jaszczur et al., 2020), aiming to improve search heuristics by leveraging predictions from GNNs. This paper is available on arxiv under CC 4.0 DEED license. Authors: (1) Ankur Nath, Department of Computer Science and Engineering, Texas A&M University; (2) Alan Kuhnle, Department of Computer Science and Engineering, Texas A&M University. Authors: Authors: (1) Ankur Nath, Department of Computer Science and Engineering, Texas A&M University; (2) Alan Kuhnle, Department of Computer Science and Engineering, Texas A&M University. Table of Links Abstract & Introduction Abstract & Introduction Related work Related work Evaluation for Max-Cut Evaluation for Max-Cut Evaluation for SAT Evaluation for SAT Summary and Outlook, References Summary and Outlook, References Supplementary Materials Supplementary Materials 2 RELATED WORK As stated before, we will limit our discussion to local search heuristics. For future reference, we will specifically refer to local search heuristics when discussing heuristics. 2.1 Classical Heuristics In this subsection, we explore works that can solve diverse CO problems without polynomial time reduction. In their influential work, Khalil et al. (2017) introduced Structure-to-Vector GNN trained with Deep Q-Networks (DQN) to address various CO problems. The resulting S2V-DQN algorithm showcased strong performance across diverse CO problems by effectively generalizing across graphs of varying sizes and topologies. Building on the work of Khalil et al. (2017) , Manchanda et al. (2019) initially trained an embedding Graph Convolution Network (GCN) in a supervised manner. Subsequently, they trained a Qnetwork using reinforcement learning (RL) to predict action values for each vertex. Their method employed GCN embeddings to prune nodes unlikely to be part of the solution set, significantly enhancing scalability compared to S2V-DQN. However, it is not applicable to problems where nodes cannot be pruned, including fundamental CO problems like the Max-Cut problem. 2.2 Generalized Learned Heuristics Barrett et al. (2020) proposed ECO-DQN, a SOTA RL algorithm for Max-Cut. ECO-DQN improves the initial solution by navigating between the local optimal points. However, ECO-DQN uses a costly GNN at each decision step, resulting in worse scalability than S2V-DQN. To address scalability challenges in ECODQN, Barrett et al. (2022) proposed ECORD. This approach limited the costly GNN to a pre-processing step and introduced a recurrent unit for fast-action selection. 2.3 Learned Heuristics for SAT In the domain of Boolean Satisfiability, the application of machine learning to solving SAT problems is not a new idea (Battiti and Protasi, 1997; Haim and Walsh, 2009; Flint and Blaschko, 2012; Grozea and Popescu, 2014; Ganesh et al., 2009; Liang et al., 2016). In recent years, there has been a trend in integrating GNNs with SAT solvers(Yolcu and P´oczos, 2019; Lederman et al., 2019; Kurin et al., 2020; Jaszczur et al., 2020), aiming to improve search heuristics by leveraging predictions from GNNs. This paper is available on arxiv under CC 4.0 DEED license. This paper is available on arxiv under CC 4.0 DEED license.

Exploring Classical and Learned Local Search Heuristics for Combinatorial Optimization

Authors:
(1) Ankur Nath, Department of Computer Science and Engineering, Texas A&M University;
(2) Alan Kuhnle, Department of Computer Science and Engineering, Texas A&M University. Table of Links Abstract & Introduction Related work Evaluation for Max-Cut Evaluation for SAT Summary and Outlook, References Supplementary Materials Abstract In recent years, combining neural networks with local search heuristics has become popular in the field of combinatorial optimization. Despite its considerable computational demands, this approach has exhibited promising outcomes with minimal manual engineering. However, we have identified three critical limitations in the empirical evaluation of these integration attempts. Firstly, instances with moderate complexity and weak baselines pose a challenge in accurately evaluating the effectiveness of learning-based approaches. Secondly, the absence of an ablation study makes it difficult to quantify and attribute improvements accurately to the deep learning architecture. Lastly, the generalization of learned heuristics across diverse distributions remains underexplored. In this study, we conduct a comprehensive investigation into these identified limitations. Surprisingly, we demonstrate that a simple learned heuristic based on Tabu Search surpasses state-of-the-art (SOTA) learned heuristics in terms of performance and generalizability. Our findings challenge prevailing assumptions and open up exciting avenues for future research and innovation in combinatorial optimization. 1 INTRODUCTION Designing effective heuristics or approximation algorithms for NP-hard combinatorial optimization (CO) problems is a challenging task, often requiring domain knowledge and extensive trial-and-error. Thus, the idea of automating this demanding and tedious design process through machine learning to learn algorithms that exploit the inherent structure of a problem has gained significant interest among researchers (Bello et al., 2016; Khalil et al., 2017; Bengio et al., 2021; Dong et al., 2021). Particularly, a considerable portion of these works (Khalil et al., 2017; Barrett et al., 2020; Yolcu and P´oczos, 2019) have concentrated on employing Graph Neural Networks (GNNs) for CO problems. Despite the computational demands, these GNN-based approaches have demonstrated competitive performance compared to SOTA heuristics tailored to specific problems. While these potential advancements offer great promise, some concerns remain. The superior performance of the learned heuristics can be attributed to the selection of specific instances and baselines. Specifically, if the baselines are weak, the learned heuristics can easily outperform them. Without hard instances and proper baseline selection, the learned heuristics can easily show comparable performance with the SOTA heuristics, and this can lead to an overestimation of the actual capabilities of the learned heuristics. Moreover, comparisons with SOTA heuristics are occasionally left out due to scalability challenges with deep learning architectures. A subset of learning-based approaches (Khalil et al., 2017; Yolcu and P´oczos, 2019; Barrett et al., 2020, 2022) incorporate the functionality or behavior of traditional heuristics, potentially offering improved or enhanced performance by integrating heuristics principles with machine learning components. If a comprehensive comparison with the integrated heuristics and an ablation study of the deep learning architecture are lacking, it becomes challenging to determine the specific contribution of the deep learning architecture. Consequently, if the integrated heuristics are robust, the learned heuristics can seamlessly outperform the baseline heuristics, while the deep learning architecture plays a little role. Another great achievement of learned heuristics (Khalil et al., 2017; Barrett et al., 2020; Toenshof et al., 2019), initially trained on smaller and specific instances from a particular distribution, exhibits impressive performance when tested on larger instances from different distributions. This achievement stands as a significant accomplishment, aligning with the core objective of employing learning-based approaches: to mitigate the necessity for extensive customization and domain-specific knowledge often required by heuristics. Although classical heuristics with hyperparameters may also encounter challenges if they are fine-tuned for a specific distribution, they may also generalize across different distributions. The primary inquiry revolves around whether the learned heuristics indeed demonstrate superior generalizability compared to classical heuristics. A thorough and insightful comparison of learned heuristics against classical heuristics provides valuable insights into the generalizability of learned heuristics. Learned heuristics often lack theoretical guarantees, making empirical evaluation the sole method to comprehend the strengths and limitations of proposed methodologies. We believe that several fundamental, yet pivotal questions remain unexplored in the empirical evaluation of these works. While these inquiries are pertinent to all types of learned heuristics, we ask and answer them by analyzing highly cited and recent peer-reviewed publications focused on learning local search heuristics. Our goal is not to provide exhaustive benchmarks for the CO problems discussed in our work but rather to assist future researchers in evaluating their research. Concretely, we ask and answer the following questions: 1. Can learned heuristics be over-parameterized? Absolutely. Replacing the GNN in ECO-DQN with linear regression and utilizing a subset of features from ECO-DQN (Barrett et al., 2020) that links to Tabu Search (Glover, 1990), we introduce a pruned version of ECO-DQN termed SoftTabu. Our study demonstrates that SoftTabu showcases superior performance and generalizability in comparison to ECO-DQN for the NPhard Maximum-Cut (Max-Cut) problem. 2. Can baseline bias be attributed to the superior performance of learned heuristics? Yes, we demonstrate that SoftTabu, a vanilla learned heuristic, can outperform S2V-DQN (Khalil et al., 2017) for the Max-Cut problem and GNNSAT (Yolcu and P´oczos, 2019) for Boolean Satisfiability (SAT). *3. Can learned heuristics demonstrate superior generalizability owing to instance selection bias?*Yes, we demonstrate that ECO-DQN shows poor generalization on harder instances and easily gets trapped in the search space. This paper is available on arxiv under CC 4.0 DEED license. Authors: (1) Ankur Nath, Department of Computer Science and Engineering, Texas A&M University; (2) Alan Kuhnle, Department of Computer Science and Engineering, Texas A&M University. Authors: Authors: (1) Ankur Nath, Department of Computer Science and Engineering, Texas A&M University; (2) Alan Kuhnle, Department of Computer Science and Engineering, Texas A&M University. Table of Links Abstract & Introduction Abstract & Introduction Related work Related work Evaluation for Max-Cut Evaluation for Max-Cut Evaluation for SAT Evaluation for SAT Summary and Outlook, References Summary and Outlook, References Supplementary Materials Supplementary Materials Abstract In recent years, combining neural networks with local search heuristics has become popular in the field of combinatorial optimization. Despite its considerable computational demands, this approach has exhibited promising outcomes with minimal manual engineering. However, we have identified three critical limitations in the empirical evaluation of these integration attempts. Firstly, instances with moderate complexity and weak baselines pose a challenge in accurately evaluating the effectiveness of learning-based approaches. Secondly, the absence of an ablation study makes it difficult to quantify and attribute improvements accurately to the deep learning architecture. Lastly, the generalization of learned heuristics across diverse distributions remains underexplored. In this study, we conduct a comprehensive investigation into these identified limitations. Surprisingly, we demonstrate that a simple learned heuristic based on Tabu Search surpasses state-of-the-art (SOTA) learned heuristics in terms of performance and generalizability. Our findings challenge prevailing assumptions and open up exciting avenues for future research and innovation in combinatorial optimization. 1 INTRODUCTION Designing effective heuristics or approximation algorithms for NP-hard combinatorial optimization (CO) problems is a challenging task, often requiring domain knowledge and extensive trial-and-error. Thus, the idea of automating this demanding and tedious design process through machine learning to learn algorithms that exploit the inherent structure of a problem has gained significant interest among researchers (Bello et al., 2016; Khalil et al., 2017; Bengio et al., 2021; Dong et al., 2021). Particularly, a considerable portion of these works (Khalil et al., 2017; Barrett et al., 2020; Yolcu and P´oczos, 2019) have concentrated on employing Graph Neural Networks (GNNs) for CO problems. Despite the computational demands, these GNN-based approaches have demonstrated competitive performance compared to SOTA heuristics tailored to specific problems. While these potential advancements offer great promise, some concerns remain. The superior performance of the learned heuristics can be attributed to the selection of specific instances and baselines. Specifically, if the baselines are weak, the learned heuristics can easily outperform them. Without hard instances and proper baseline selection, the learned heuristics can easily show comparable performance with the SOTA heuristics, and this can lead to an overestimation of the actual capabilities of the learned heuristics. Moreover, comparisons with SOTA heuristics are occasionally left out due to scalability challenges with deep learning architectures. A subset of learning-based approaches (Khalil et al., 2017; Yolcu and P´oczos, 2019; Barrett et al., 2020, 2022) incorporate the functionality or behavior of traditional heuristics, potentially offering improved or enhanced performance by integrating heuristics principles with machine learning components. If a comprehensive comparison with the integrated heuristics and an ablation study of the deep learning architecture are lacking, it becomes challenging to determine the specific contribution of the deep learning architecture. Consequently, if the integrated heuristics are robust, the learned heuristics can seamlessly outperform the baseline heuristics, while the deep learning architecture plays a little role. Another great achievement of learned heuristics (Khalil et al., 2017; Barrett et al., 2020; Toenshof et al., 2019), initially trained on smaller and specific instances from a particular distribution, exhibits impressive performance when tested on larger instances from different distributions. This achievement stands as a significant accomplishment, aligning with the core objective of employing learning-based approaches: to mitigate the necessity for extensive customization and domain-specific knowledge often required by heuristics. Although classical heuristics with hyperparameters may also encounter challenges if they are fine-tuned for a specific distribution, they may also generalize across different distributions. The primary inquiry revolves around whether the learned heuristics indeed demonstrate superior generalizability compared to classical heuristics. A thorough and insightful comparison of learned heuristics against classical heuristics provides valuable insights into the generalizability of learned heuristics. Learned heuristics often lack theoretical guarantees, making empirical evaluation the sole method to comprehend the strengths and limitations of proposed methodologies. We believe that several fundamental, yet pivotal questions remain unexplored in the empirical evaluation of these works. While these inquiries are pertinent to all types of learned heuristics, we ask and answer them by analyzing highly cited and recent peer-reviewed publications focused on learning local search heuristics. Our goal is not to provide exhaustive benchmarks for the CO problems discussed in our work but rather to assist future researchers in evaluating their research. Concretely, we ask and answer the following questions: 1. Can learned heuristics be over-parameterized? Absolutely. Replacing the GNN in ECO-DQN with linear regression and utilizing a subset of features from ECO-DQN (Barrett et al., 2020) that links to Tabu Search (Glover, 1990), we introduce a pruned version of ECO-DQN termed SoftTabu. Our study demonstrates that SoftTabu showcases superior performance and generalizability in comparison to ECO-DQN for the NPhard Maximum-Cut (Max-Cut) problem. 1. Can learned heuristics be over-parameterized? Absolutely. 2. Can baseline bias be attributed to the superior performance of learned heuristics? Yes, we demonstrate that SoftTabu, a vanilla learned heuristic, can outperform S2V-DQN (Khalil et al., 2017) for the Max-Cut problem and GNNSAT (Yolcu and P´oczos, 2019) for Boolean Satisfiability (SAT). 2. Can baseline bias be attributed to the superior performance of learned heuristics? *3. Can learned heuristics demonstrate superior generalizability owing to instance selection bias?*Yes, we demonstrate that ECO-DQN shows poor generalization on harder instances and easily gets trapped in the search space. This paper is available on arxiv under CC 4.0 DEED license. This paper is available on arxiv under CC 4.0 DEED license.

Unveiling the Limits of Learned Local Search Heuristics: Are You the Mightiest of the Meek?

শেখা স্থানীয় অনুসন্ধান হিউরিস্টিকসের সীমা উন্মোচন করা: আপনি কি নম্রদের মধ্যে সবচেয়ে শক্তিশালী?

Die Grenzen erlernter Heuristiken für die lokale Suche aufdecken: Sind Sie der Mächtigste unter den Sanftmütigen?

Revelando los límites de la heurística de búsqueda local aprendida: ¿eres el más poderoso entre los mansos?

Dévoiler les limites des heuristiques de recherche locale apprises : êtes-vous le plus puissant des doux ?

सीखी गई स्थानीय खोज हेयुरिस्टिक्स की सीमाओं का अनावरण: क्या आप नम्र लोगों में सबसे शक्तिशाली हैं?

学習したローカル検索ヒューリスティックスの限界を明らかにする: あなたは最も強い弱者ですか?

학습된 지역 검색 휴리스틱의 한계 공개: 당신은 가장 온유한 사람입니까?

Revelando os limites das heurísticas de pesquisa local aprendidas: você é o mais poderoso dos mansos?

Раскрытие границ изученной эвристики локального поиска: вы самый могущественный из кротких?

Öğrenilmiş Yerel Arama Buluşsal Yöntemlerinin Sınırlarını Ortaya Çıkarıyoruz: Uysalların En Güçlüsü Siz misiniz?

Tiết lộ các giới hạn của phương pháp phỏng đoán tìm kiếm địa phương đã học: Bạn có phải là người mạnh mẽ nhất trong số những người nhu mì không?

揭示学习本地搜索启发式方法的局限性：你是最强大的吗？

How to Backup Your DEV.to Articles Locally in Markdown Format

In this article, I’ll guide you through C# Testcontainers for MongoDB! I love using Testcontainers for local database work when I don’t want to think about managing the overhead of spinning up and tearing down a database, or managing something in the cloud. MongoDB is no exception here as the C# Testcontainers NuGet package that we have for MongoDB is a dream to work with. In this article, I’ll introduce you to the basics of Testcontainers. From there, I’ll demonstrate how simple it is to interact with your newly created database via the C# MongoDB.Driver NuGet package — almost like you wouldn’t even know there was a container spun up! Let’s dive into it. Overview of C# Testcontainers Testcontainers is an awesome NuGet package that can greatly enhance your testing and local development workflow when building .NET applications. It provides a simple and effective way to manage Docker containers, allowing you to spin up lightweight and isolated instances and have them tear down like nothing ever happened! That means with Testcontainers, you no longer have to worry about setting up and tearing down test databases or dealing with complex configuration files. It handles all the details of container management, making this process feel trivial — I sure wouldn’t want to handle this manually. Some of the key benefits of Testcontainers include: Its ability to provide a consistent and reproducible test environment. You can define the exact service version and configuration that you require, ensuring that your test results are reliable and consistent across different environments. The speed and flexibility it brings to your testing and development workflow. By using lightweight Docker containers, you can quickly spin up and tear down test environments on demand. No configuring cloud or shared resources ahead of time… Just on-the-fly awesomeness. Seamless integration with existing testing frameworks and tools in the DotNet ecosystem, such as Xunit, NUnit, and BenchmarkDotNet. This allows you to easily incorporate containerized service instances into your existing test suites without any major modifications. For this article, we’ll be focusing on how we can use C# Testcontainers for MongoDB in particular. Much of the advice covered here will be applicable to other services, especially databases, but we’ll keep our sights set on MongoDB. Setting Up Testcontainers in C# To get started with Testcontainers in C#, you’ll need to install and configure the necessary dependencies in your project. Follow the steps below to set up Testcontainers for MongoDB in C#. 1. Installing Testcontainers Generally, the first step would be to install the Testcontainers NuGet package in your C# project. You would open the NuGet Package Manager Console, and run the following command: Install-Package Testcontainers However, we need the MongoDB flavor of this package (I am using version 3.8.0 at the time of writing) which includes the base Testcontainers package. You can install it via the package manager user interface or with this command: Install-Package Testcontainers.MonogoDB 2. Configuring Testcontainers for MongoDB Once you have installed Testcontainers, you need to configure it for MongoDB. This involves setting up a MongoDB container with the required settings. Here is an example of how you can configure Testcontainers for MongoDB in C#: using Testcontainers.MongoDb;

MongoDbContainer container = new MongoDbBuilder()
    .WithImage("mongo:latest")
    .Build(); In the above example, we create a new instance of the , and specify the MongoDB image and port binding. The method sets the image for the MongoDB container, so using “mongo:latest” will always pull the latest image. MongoDbBuilder WithImage Optionally, we could use port binding to configure which ports we want to be using explicitly: using Testcontainers.MongoDb;

MongoDbContainer container = new MongoDbBuilder()
    .WithImage("mongo:latest")
    .WithPortBinding(1337, 27017)
    .Build(); The code above uses method binds the container’s port 27017 to the host machine’s port 1337. We’ll see in the upcoming sections that unless you have a specific need to bind ports, you can potentially just leave this be. We can get a dynamic connection string, which is very convenient! WithPortBinding 3. Starting and Stopping the MongoDB Container After configuring Testcontainers for MongoDB, you can start and stop the container as needed. Here are code examples for starting and stopping the container: To start the MongoDB container: await container.StartAsync(); To stop the MongoDB container: await _container.StopAsync(); Remember the MongoDbContainer type can be disposed of, so call to clean up when you’re ready. DisposeAsync Using C# Testcontainers for MongoDB in Practice Now that we’ve seen how to spin up and tear down containers, what are we supposed to do with them? We have plenty of options, and truly, the limit is your own imagination (and time, money, and other resources…)! Most people leverage C# Testcontainers for writing integration or . You can match up Testcontainers with xUnit or NUnit, for example, and write tests that interact with a real database. functional tests For me, I needed to go wire C# Testcontainers for MongoDB up to BenchmarkDotNet so I could ! A similar use case where I needed transient local databases, but not necessarily for a test framework. benchmark inserting records into MongoDB Regardless, we need to be able to connect to these MongoDB database containers from C#, and these next subsections will cover that. Connecting to C# Testcontainers for MongoDB with MongoDB.Driver Let’s assume you read the earlier sections and you have the correct MongoDB package installed for Testcontainers. If you skimmed ahead to this section, go back, read it, and get the right package. Otherwise, you’ll be scratching your head about why you can’t find the right dependencies! You’ll also need to get the MongoDB.Driver NuGet package installed. This is what we’re going to be using to establish a connection to the database container that we spun up. I have other articles you can read if you want more explanation on how MongoDB.Driver works in general: MongoDB in C#: Simplified Guide For Inserting Data MongoDB Filtering in C# – Beginner’s Guide For Easy Filters How To Delete Documents From MongoDB In C# – What You Need To Know How To Update MongoDB Documents in C# – What You Need To Know With the right packages ready to go, we can combine the code we saw earlier with some MongoDB driver code to get things glued together: using MongoDB.Bson;
using MongoDB.Driver;

using Testcontainers.MongoDb;

MongoDbContainer container = new MongoDbBuilder()
    .WithImage("mongo:latest")
    .Build();
await container.StartAsync();
string connectionString = container.GetConnectionString();

MongoClient mongoClient = new MongoClient(connectionString);
IMongoDatabase database = mongoClient.GetDatabase("test");
IMongoCollection<BsonDocument> collection = database.GetCollection<BsonDocument>("test"); In the example above, we can call on the newly spun-up MongoDB container from Testcontainers. The awesome part about this is that no matter how you configure your Testcontainer for MongoDB using the builder pattern we see in this code and earlier in the article, will get you what you need to connect. GetConnectionString() GetConnectionString() Because takes in a connection string as a single argument, it’s trivial to get access to the MongoDB database to start working with it right away! MongoClient Performing CRUD Operations on the MongoDB Testcontainer Now that we have our MongoDB Testcontainer set up and we have a connected to it, we can start performing CRUD operations on it. The connection details provided by the container instance made it a breeze to combine these two things, and truly, we can focus on just the MongoDB.Driver method calls for CRUD. MongoClient Here’s an example of performing a simple CRUD operation: // using code from earlier examples...

// Create
await collection.InsertOneAsync(new BsonDocument()
{
    ["Name"] = "Nick Cosentino",
});

// Read
var filterBuilder = Builders<BsonDocument>.Filter;
var filter = filterBuilder.Eq("Name", "Nick Cosentino");
var results = collection.Find(filter);

// Update
var updateBuilder = Builders<BsonDocument>.Update;
var update = updateBuilder.Set("Name", "Dev Leader");
collection.UpdateOne(filter, update);

// Delete
filter = filterBuilder.Eq("Name", "Dev Leader");
collection.DeleteOne(filter); Using the previous code snippets, we were already up and running with our MongoDB container instance and a . As a result, you can see in the code snippet above that we can directly work with our that we obtained from the prior setup. MongoClient IMongoCollection<BsonDocument> This helps illustrate that once you have the MongoDB docker container up and running via Testcontainers, you don’t have to treat things any special way once you connect to it! Wrapping Up C# Testcontainers for MongoDB To conclude, C# Testcontainers for MongoDB is an incredibly simple way to get a transient MongoDB data store up and running for your testing and development. While this article didn’t focus on specific use cases, hopefully, you have a better understanding of how transparent it feels to layer a MongoDB driver on top of Testcontainers to interact with MongoDB. Given that C# Testcontainers takes the headache out of the setup, teardown, and even connection string management, it’s an easy recommendation from me if you want to get up and running with MongoDB for local usage. If you found this useful and you’re looking for more learning opportunities, consider , and check out my ! subscribing to my free weekly software engineering newsletter free videos on YouTube Also published here

Easily Run Local Databases Using C# Testcontainers for MongoDB

MongoDB-এর জন্য C# টেস্ট কনটেইনার ব্যবহার করে সহজেই স্থানীয় ডেটাবেস চালান

Führen Sie ganz einfach lokale Datenbanken mit C#-Testcontainern für MongoDB aus

Ejecute fácilmente bases de datos locales utilizando C# Testcontainers para MongoDB

Exécutez facilement des bases de données locales à l'aide de C# Testcontainers pour MongoDB

MongoDB के लिए C# टेस्टकंटेनर का उपयोग करके आसानी से स्थानीय डेटाबेस चलाएँ

MongoDB 用の C# Testcontainers を使用してローカル データベースを簡単に実行する

MongoDB용 C# 테스트 컨테이너를 사용하여 로컬 데이터베이스를 쉽게 실행

Execute facilmente bancos de dados locais usando C# Testcontainers para MongoDB

Легко запускайте локальные базы данных с помощью тестовых контейнеров C# для MongoDB

MongoDB için C# Testcontainer'larını Kullanarak Yerel Veritabanlarını Kolayca Çalıştırın

Dễ dàng chạy cơ sở dữ liệu cục bộ bằng C# Testcontainer cho MongoDB

使用 MongoDB 的 C# 测试容器轻松运行本地数据库

After my latest post about how to build your own RAG and run it locally, today, we're taking it a step further by not only implementing the conversational abilities of large language models but also adding listening and speaking capabilities. The idea is straightforward: we are going to create a voice assistant reminiscent of Jarvis or Friday from the iconic Iron Man movies, which can operate offline on your computer. Since this is an introductory tutorial, I will implement it in Python and keep it simple enough for beginners. Lastly, I will provide some guidance on how to scale the application. Techstack First, you should set up a virtual Python environment. You have several options for this, including pyenv, virtualenv, poetry, and others that serve a similar purpose. Personally, I'll use Poetry for this tutorial due to my personal preferences. Here are several crucial libraries you'll need to install: : For a visually appealing console output. rich : A robust tool for speech-to-text conversion. openai-whisper : A cutting-edge library for text-to-speech synthesis, ensuring high-quality audio output. suno-bark : A straightforward library for interfacing with Large Language Models (LLMs). langchain , , and : Essential for audio recording and playback. sounddevice pyaudio speechrecognition For a detailed list of dependencies, refer to the link . here The most critical component here is the Large Language Model (LLM) backend, for which we will use Ollama. is widely recognized as a popular tool for running and serving LLMs offline. If Ollama is new to you, I recommend checking out my previous article on offline RAG: Basically, you just need to download the Ollama application, pull your preferred model, and run it. Ollama "Build Your Own RAG and Run It Locally: Langchain + Ollama + Streamlit." Architecture Okay, if everything has been set up, let's proceed to the next step. Below is the overall architecture of our application, which fundamentally comprises 3 main components: : Utilizing , we convert spoken language into text. Whisper's training on diverse datasets ensures its proficiency across various languages and dialects. Speech Recognition OpenAI's Whisper : For the conversational capabilities, we'll employ the Langchain interface for the model, which is served using Ollama. This setup promises a seamless and engaging conversational flow. Conversational Chain Llama-2 : The transformation of text to speech is achieved through , a state-of-the-art model from Suno AI, renowned for its lifelike speech production. Speech Synthesizer Bark The workflow is straightforward: record speech, transcribe to text, generate a response using an LLM, and vocalize the response using Bark. Sequence diagram for voice assistant with Whisper, Ollama, and Bark. Implementation The implementation begins with crafting a based on Bark, incorporating methods for synthesizing speech from text and handling longer text inputs seamlessly as follows: TextToSpeechService import nltk
import torch
import warnings
import numpy as np
from transformers import AutoProcessor, BarkModel

warnings.filterwarnings(
    "ignore",
    message="torch.nn.utils.weight_norm is deprecated in favor of torch.nn.utils.parametrizations.weight_norm.",
)


class TextToSpeechService:
    def __init__(self, device: str = "cuda" if torch.cuda.is_available() else "cpu"):
        """
        Initializes the TextToSpeechService class.
        Args:
            device (str, optional): The device to be used for the model, either "cuda" if a GPU is available or "cpu".
            Defaults to "cuda" if available, otherwise "cpu".
        """
        self.device = device
        self.processor = AutoProcessor.from_pretrained("suno/bark-small")
        self.model = BarkModel.from_pretrained("suno/bark-small")
        self.model.to(self.device)

    def synthesize(self, text: str, voice_preset: str = "v2/en_speaker_1"):
        """
        Synthesizes audio from the given text using the specified voice preset.
        Args:
            text (str): The input text to be synthesized.
            voice_preset (str, optional): The voice preset to be used for the synthesis. Defaults to "v2/en_speaker_1".
        Returns:
            tuple: A tuple containing the sample rate and the generated audio array.
        """
        inputs = self.processor(text, voice_preset=voice_preset, return_tensors="pt")
        inputs = {k: v.to(self.device) for k, v in inputs.items()}

        with torch.no_grad():
            audio_array = self.model.generate(**inputs, pad_token_id=10000)

        audio_array = audio_array.cpu().numpy().squeeze()
        sample_rate = self.model.generation_config.sample_rate
        return sample_rate, audio_array

    def long_form_synthesize(self, text: str, voice_preset: str = "v2/en_speaker_1"):
        """
        Synthesizes audio from the given long-form text using the specified voice preset.
        Args:
            text (str): The input text to be synthesized.
            voice_preset (str, optional): The voice preset to be used for the synthesis. Defaults to "v2/en_speaker_1".
        Returns:
            tuple: A tuple containing the sample rate and the generated audio array.
        """
        pieces = []
        sentences = nltk.sent_tokenize(text)
        silence = np.zeros(int(0.25 * self.model.generation_config.sample_rate))

        for sent in sentences:
            sample_rate, audio_array = self.synthesize(sent, voice_preset)
            pieces += [audio_array, silence.copy()]

        return self.model.generation_config.sample_rate, np.concatenate(pieces) : The class takes an optional parameter, which specifies the device to be used for the model (either if a GPU is available, or ). It loads the Bark model and the corresponding processor from the pre-trained model. You can also use the large version by specifying for the model loader. Initialization ( __init__ ) device cuda cpu suno/bark-small suno/bark : This method takes a input and a parameter, which specifies the voice to be used for the synthesis. You can check out other value . It uses the to prepare the input text and the voice preset, and then generates the audio array using the method. The generated audio array is converted to a NumPy array and the sample rate is returned along with the audio array. Synthesize ( synthesize ) text voice_preset voice_preset here processor model.generate() : This method is used for synthesizing longer text inputs. It first tokenizes the input text into sentences using the function. For each sentence, it calls the method to generate the audio array. It then concatenates the generated audio arrays, with a short silence (0.25 seconds) added between each sentence. Long-form Synthesize ( long_form_synthesize ) nltk.sent_tokenize synthesize Now that we have the set up, we need to prepare the Ollama server for the large language model (LLM) serving. To do this, you'll need to follow these steps: TextToSpeechService : Run the following command to download the latest Llama-2 model from the Ollama repository: Pull the latest Llama-2 model ollama pull llama2 . : If the server is not yet started, execute the following command to start it: . Start the Ollama server ollama serve Once you've completed these steps, your application will be able to use the Ollama server and the Llama-2 model to generate responses to user input. Next, we'll move to the main application logic. First, we need to initialize the following components: : We'll use the Rich library to create a better interactive console for the user within the terminal. Rich Console : We'll initialize a Whisper speech recognition model which is a state-of-the-art open-source speech recognition system developed by OpenAI. We'll use the base English model ( ) for transcribing user input. Whisper Speech-to-Text base.en : We'll initialize a Bark text-to-speech synthesizer instance, which was implemented above. Bark Text-to-Speech : We'll use the built-in from the Langchain library which provides a template for managing the conversational flow. We'll configure it to use the Llama-2 language model with the Ollama backend. Conversational Chain ConversationalChain import time
import threading
import numpy as np
import whisper
import sounddevice as sd
from queue import Queue
from rich.console import Console
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate
from langchain_community.llms import Ollama
from tts import TextToSpeechService

console = Console()
stt = whisper.load_model("base.en")
tts = TextToSpeechService()

template = """
You are a helpful and friendly AI assistant. You are polite, respectful, and aim to provide concise responses of less 
than 20 words.
The conversation transcript is as follows:
{history}
And here is the user's follow-up: {input}
Your response:
"""
PROMPT = PromptTemplate(input_variables=["history", "input"], template=template)
chain = ConversationChain(
    prompt=PROMPT,
    verbose=False,
    memory=ConversationBufferMemory(ai_prefix="Assistant:"),
    llm=Ollama(),
) Now, let's define the necessary functions: : This function runs in a separate thread to capture audio data from the user's microphone using the . The callback function is called whenever new audio data is available, and it puts the data into a for further processing. record_audio sounddevice.RawInputStream data_queue : This function utilizes the Whisper instance to transcribe the audio data from the into text. transcribe data_queue : This function feeds the current conversation context to the Llama-2 language model (via the Langchain ) and retrieves the generated text response. get_llm_response ConversationalChain : This function takes the audio waveform generated by the Bark text-to-speech engine and plays it back to the user using a sound playback library (e.g., ). play_audio sounddevice def record_audio(stop_event, data_queue):
    """
    Captures audio data from the user's microphone and adds it to a queue for further processing.
    Args:
        stop_event (threading.Event): An event that, when set, signals the function to stop recording.
        data_queue (queue.Queue): A queue to which the recorded audio data will be added.
    Returns:
        None
    """
    def callback(indata, frames, time, status):
        if status:
            console.print(status)
        data_queue.put(bytes(indata))

    with sd.RawInputStream(
        samplerate=16000, dtype="int16", channels=1, callback=callback
    ):
        while not stop_event.is_set():
            time.sleep(0.1)

def transcribe(audio_np: np.ndarray) -> str:
    """
    Transcribes the given audio data using the Whisper speech recognition model.
    Args:
        audio_np (numpy.ndarray): The audio data to be transcribed.
    Returns:
        str: The transcribed text.
    """
    result = stt.transcribe(audio_np, fp16=False)  # Set fp16=True if using a GPU
    text = result["text"].strip()
    return text

def get_llm_response(text: str) -> str:
    """
    Generates a response to the given text using the Llama-2 language model.
    Args:
        text (str): The input text to be processed.
    Returns:
        str: The generated response.
    """
    response = chain.predict(input=text)
    if response.startswith("Assistant:"):
        response = response[len("Assistant:") :].strip()
    return response

def play_audio(sample_rate, audio_array):
    """
    Plays the given audio data using the sounddevice library.
    Args:
        sample_rate (int): The sample rate of the audio data.
        audio_array (numpy.ndarray): The audio data to be played.
    Returns:
        None
    """
    sd.play(audio_array, sample_rate)
    sd.wait() Then, we define the main application loop. The main application loop guides the user through the conversational interaction as follows: The user is prompted to press Enter to start recording their input. Once the user presses Enter, the function is called in a separate thread to capture the user's audio input. record_audio When the user presses Enter again to stop the recording, the audio data is transcribed using the function. transcribe The transcribed text is then passed to the function, which generates a response using the Llama-2 language model. get_llm_response The generated response is printed to the console and played back to the user using the function. play_audio if __name__ == "__main__":
    console.print("[cyan]Assistant started! Press Ctrl+C to exit.")

    try:
        while True:
            console.input(
                "Press Enter to start recording, then press Enter again to stop."
            )

            data_queue = Queue()  # type: ignore[var-annotated]
            stop_event = threading.Event()
            recording_thread = threading.Thread(
                target=record_audio,
                args=(stop_event, data_queue),
            )
            recording_thread.start()

            input()
            stop_event.set()
            recording_thread.join()

            audio_data = b"".join(list(data_queue.queue))
            audio_np = (
                np.frombuffer(audio_data, dtype=np.int16).astype(np.float32) / 32768.0
            )

            if audio_np.size > 0:
                with console.status("Transcribing...", spinner="earth"):
                    text = transcribe(audio_np)
                console.print(f"[yellow]You: {text}")

                with console.status("Generating response...", spinner="earth"):
                    response = get_llm_response(text)
                    sample_rate, audio_array = tts.long_form_synthesize(response)

                console.print(f"[cyan]Assistant: {response}")
                play_audio(sample_rate, audio_array)
            else:
                console.print(
                    "[red]No audio recorded. Please ensure your microphone is working."
                )

    except KeyboardInterrupt:
        console.print("\n[red]Exiting...")

    console.print("[blue]Session ended.") Result Once everything is put down together, we can run the application as shown in the video above. The application runs quite slowly on my MacBook because the Bark model is large, even in its smaller version. Therefore, I have slightly sped up the video. For those with a CUDA-enabled computer, it might run faster. Here are the key features of our application: : Users can start and stop recording their voice input, and the assistant responds by playing back the generated audio. Voice-based interaction The assistant maintains the context of the conversation, enabling more coherent and relevant responses. The use of the Llama-2 language model allows the assistant to provide concise and focused responses. Conversational context: For those aiming to elevate this application to a production-ready status, the following enhancements are recommended: : Incorporate optimized versions of the models, such as whisper.cpp, llama.cpp, and bark.cpp, which are designed to boost performance, especially on lower-end computers. Performance Optimization : Implement a system that allows users to customize the bot's persona and prompt, enabling the creation of different types of assistants (e.g., personal, professional, or domain-specific). Customizable Bot Prompts : Develop a user-friendly GUI to enhance the overall user experience, making the application more accessible and visually appealing. Graphical User Interface (GUI) : Expand the application to support multimodal interactions, such as the ability to generate and display images, diagrams, or other visual content in addition to the voice-based responses. Multimodal Capabilities Finally, we have completed our simple voice assistant application, full code can be found at: . This combination of speech recognition, language modeling, and text-to-speech technologies demonstrates how we can build something that sounds difficult but can actually run on your computer. Let's enjoy coding, and don't forget to subscribe to so you don't miss the latest in AI and programming articles. https://github.com/vndee/local-talking-llm my blog Also published here

How to Build Your Own Voice Assistant and Run it Locally Using Whisper + Ollama + Bark

কীভাবে আপনার নিজের ভয়েস সহকারী তৈরি করবেন এবং হুইস্পার + ওল্লামা + বার্ক ব্যবহার করে স্থানীয়ভাবে এটি চালাবেন

So erstellen Sie Ihren eigenen Sprachassistenten und führen ihn lokal mit Whisper + Ollama + Bark aus

Cómo crear su propio asistente de voz y ejecutarlo localmente usando Whisper + Ollama + Bark

Comment créer votre propre assistant vocal et l'exécuter localement à l'aide de Whisper + Ollama + Bark

अपना खुद का वॉयस असिस्टेंट कैसे बनाएं और इसे व्हिस्पर + ओलामा + बार्क का उपयोग करके स्थानीय रूप से कैसे चलाएं

独自の音声アシスタントを構築し、Whisper + Ollama + Bark を使用してローカルで実行する方法

나만의 음성 어시스턴트를 구축하고 Whisper + Ollama + Bark를 사용하여 로컬에서 실행하는 방법

Como construir seu próprio assistente de voz e executá-lo localmente usando Whisper + Ollama + Bark

Как создать собственный голосовой помощник и запустить его локально с помощью Whisper + Ollama + Bark

Kendi Sesli Asistanınızı Oluşturma ve Whisper + Ollama + Bark Kullanarak Yerel Olarak Çalıştırma

Cách xây dựng trợ lý giọng nói của riêng bạn và chạy nó cục bộ bằng Whisper + Ollama + Bark

如何构建您自己的语音助手并使用 Whisper + Ollama + Bark 在本地运行

on how to integrate the into any React application with automatic reacquisition of a lock using . TLDR: LIVE demo 🚀 Screen Wake Lock API react-use-wake-lock Historically, browsers didn't support any APIs to control sleep settings. Devices usually turn off displays after some time to improve power usage, improve security, and prolong the life of hardware in general. However, this behavior does not always provide the best UX for users. In some cases, browsers are smart enough to prevent sleep by using heuristics like playing video. Some libraries utilize this to hack solutions for this problem (e.g., ). However, this comes with an extra penalty hit on performance and battery. NoSleep.js Modern browsers now support an official API to manage this process. This provides more reliable control over the sleep functionality. In certain scenarios, it's perfectly reasonable to prevent the device from locking (for instance, in systems like navigation, photo galleries, calling, etc.), which significantly enhances the overall user experience. Although this API is not fully standardized and is still in the stage, it has extensive browser support. This is particularly noteworthy since it is now also supported by Safari version 16.4 and above (including mobile Safari). As such, this API is currently . Working Draft supported by the majority of major browsers Let's take a closer look at how to use it in practice and what are its limitations. Screen Wake Lock API There are 3 important limitations when you are allowed to use this API: Your app should be in an active tab. Your app should be served from the . Secure Context Using this feature is not blocked by the Permissions Policy The API itself is quite straightforward and involves two steps: requesting a lock and releasing it. Being Promise-based, you need to wait for the promise to resolve in order to acquire the lock. There are two main parts in the API: - Interface that can be used to request the lock from the browser. WakeLock - Interface to the underlying lock that can be used to release the lock WakeLockSentinel So, let's connect all the pieces together. Requesting a Lock To request a lock, we need to use and invoke method. You need to provide the type of lock, but only type is supported at this moment. navigator.wakelock request() screen const requestScreenWakeLock = async () => {
  // Check if wakelock API is available
  if (!("wakeLock" in navigator)) {
    console.error("Screen Wake Lock API is not supported by the browser");
    return;
  }

  try {
    const wakeLock = await navigator.wakeLock.request("screen");
  } catch (err) {
    // There are various reason why lock might not be acquired such as tab is not active, low battery on a device, permissions
    console.error(`WakeLock request error: ${err.message}`);
  }
}; It's important to note that the browser might reject the request for several reasons, such as low battery level or page visibility, among others. Therefore, it's crucial to ensure that the Promise has been resolved to ensure success. Releasing a Lock Once you have a from API,  you can use it to release a lock. For this, you can simply call method on it and wait for the to resolve. You can also check the status of a lock in a property and . WakeLockSentinel request() release() Promise released type The simplest snippet: try {
  console.log('Released state before: 'wakeLock.released); // false

  await wakeLock.release();

  console.log('Released state after: 'wakeLock.released); // true
} catch (err) {
  console.error(`WakeLock release error: ${err.message}`);
} It's important to note that the browser might decide to release the lock even without a specific request from you. Therefore, to keep the state of the app in sync with the lock status, it's crucial to listen for the wake lock release event. wakeLock.addEventListener("release", () => {
  // the wake lock has been released
  console.log('Wake Lock has been released');
}); While the API itself appears quite straightforward, there are some nuances to consider when implementing it. For instance, since the lock will be auto-released when the browser is no longer active, you'll need to manage this aspect yourself. This involves listening for visibility changes in order to reacquire the lock. For pure JS implementation, you can check the and . MDN example source code However, in order to integrate it into a React-based app, it would be much easier to have a wrapper that provides a hook-based API to work with Screen Wake Lock API. Using Screen Wake Lock API in React I have wrapped this API into a React hook to make it much easier to use in any React application. The library offers a simple way to hide the complexities of handling the async nature of Screen Wake Lock API as well as automatically incorporate automatic reacquisition of a lock in case the app loses visibility (becomes inactive). react-use-wake-lock Additionally, it also supports TypeScript and has 100% test-coverage. Let's take a look at the simplest example. First, you need to install this library by running (or / depending on your preference) npm install react-use-wake-lock --save pnpm yarn Then, just add it to your React files as shown in a minimal example below import useWakeLock from "react-use-wake-lock";

function MinimalExampleComponent() {
  const { isSupported, isLocked, request, release } = useWakeLock();

  // isSupported: boolean - checks feature is supported by the browser
  // isLocked: boolean    - checks lock is currently active
  // request: () => void  - request lock, once successfully acquired isLocked will change to TRUE
  // release: () => void  - release the lock, once successfully released isLocked will change to FALSE

  return (
    <div>
      <h3>Screen Wake Lock API supported: {isSupported ? "Yes" : "No"}</h3>
      <h3>Locked: {`${isLocked ? "Yes" : "No"}`}</h3>
      <button type="button" onClick={() => (isLocked ? release() : request())}>
        {isLocked ? "Release" : "Request"}
      </button>
    </div>
  );
} This is just a . However, the library offers more control and error handling by specifying extra options to the hook. Feel free to check the or . minimal example full example code official documentation You can check this example or check the . minimal demo full example with support for events and error handling End-to-end demo on iOS (Safari) Conclusion Leveraging modern browser APIs is a powerful strategy that allows us to construct a superior user experience, effectively bridging the gap between web and native applications by bringing an app-like feel to the web. This article serves as a hands-on guide detailing how to utilize the modern Screen Wake Lock API within any application built on React. You can find the complete source code as well as demo and installation instructions for this example on GitHub . https://github.com/dlitsman/react-use-wake-lock

How to Use Screen Wake Lock API in React to Manage Screen Locking/Dimming in a Browser

The Noonification: Using pgvector To Locate Similarities In Enterprise Data (3/22/2024)

Using pgvector To Locate Similarities In Enterprise Data

এন্টারপ্রাইজ ডেটাতে মিল খুঁজে পেতে pgvector ব্যবহার করা

Verwenden von pgvector zum Auffinden von Ähnlichkeiten in Unternehmensdaten

Uso de pgvector para localizar similitudes en datos empresariales

Utilisation de pgvector pour localiser les similitudes dans les données d'entreprise

एंटरप्राइज़ डेटा में समानताएँ खोजने के लिए pgvector का उपयोग करना

pgvector を使用して企業データ内の類似点を特定する

pgVector를 사용하여 기업 데이터의 유사점 찾기

Usando pgvector para localizar semelhanças em dados corporativos

Использование pgvector для поиска сходств в корпоративных данных

Kurumsal Verilerdeki Benzerlikleri Bulmak İçin pgvector'u Kullanma

Sử dụng pgvector để xác định điểm tương đồng trong dữ liệu doanh nghiệp

使用 pgvector 查找企业数据中的相似之处

How to Run Your Own Local LLM: Updated for 2024 - Version 1

কিভাবে আপনার নিজের স্থানীয় LLM চালাবেন (2024 এর জন্য আপডেট করা হয়েছে)

So führen Sie Ihren eigenen lokalen LLM durch (Aktualisiert für 2024)

Cómo ejecutar su propio LLM local (actualizado para 2024)

Comment gérer votre propre LLM local (mis à jour pour 2024)

अपना खुद का स्थानीय एलएलएम कैसे चलाएं (2024 के लिए अपडेट किया गया)

独自のローカル LLM を運営する方法 (2024 年更新)

자신만의 지역 LLM을 운영하는 방법(2024년 업데이트)

Como executar seu próprio LLM local (atualizado para 2024)

Как запустить собственный местный LLM (обновлено для 2024 г.)

Kendi Yerel LLM'nizi Nasıl Yönetirsiniz (2024 için Güncellendi)

Cách chạy LLM địa phương của riêng bạn (Cập nhật năm 2024)

如何开办自己的本地法学硕士 (2024 年更新)

Professionals outside the managed IT and trades tend to think about losses in terms of the cryptocurrency demands made by hackers. While extortion drives the criminal scheme, the total cost of a ransomware attack can be more crippling than the payoff alone. Once officials in local municipalities and state agencies understand the full impact of having their sensitive data and networks held hostage. As such, the need for proactive measures becomes a matter of urgency. cybersecurity ransomware attack Facts About Ransomware Attacks Government Officials Need to Know Ransomware attacks only garner news headlines when the wings of the government or high-profile corporations get ensnared. For example, when MGM Grand and Caesars by the Scattered Spiders hacker gang, news of the $15 million payoff went viral. And when DarkSide hackers put the Colonial Pipeline under siege, upwards of 5,500 miles of fuel distribution lines were crippled. The company’s inability to deliver gasoline caused massive fuel shortages across multiple states. Only after paying thieves did gasoline and diesel start flowing again. casinos were stung $5 million These highlight the fact hackers are willing to attack any network with impunity, even those of local and state governments: ransomware statistics The average cost of a 2023 ransomware attack has nearly doubled from 2022 to $1.54 million. Companies grind to a standstill for 22 days, on average, during a ransomware attack. Nearly a half-billion ransomware attacks were launched in 2022. U.S. organizations are the most heavily targeted, accounting for 47 percent of global attacks. But what did not necessarily make the splashiest of headlines was the long-term fallout from the digital hostage situations reported by the media. It’s not uncommon for organizations to experience a second attack after paying a crypto demand. Approximately 30 percent of private-sector companies that were overrun by cybercriminals suffered in the brand — some ended up filing for bankruptcy. diminished confidence The private sector, of course, is not the only target of ransomware attacks. Governments, too, make tempting targets, given that public IT infrastructure can be infamously behind the times. With citizens already critical of local, state, and federal government decisions and the use of taxpayer dollars, lost confidence is the last thing elected and non-elected officials need. Ransomware Attack Threats to Local & State Governments Decision-makers need to understand that hackers continue to target weak, almost defenseless networks and employees who lack cybersecurity awareness training. That’s largely why — the use of malware-laced electronic messages — remains hackers’ delivery method of choice. Whether a new hire in training clicks on the wrong link or an elected official gets conned into downloading a malicious file, the consequences are the same. These are ways one mistake can send a municipality into a tailspin. phishing Financial Impact on Taxpayers States such as Florida passed laws banning the practice of paying hacker ransom demands, and many others are mulling over whether to follow suit. With the average cost hovering around $1.54 million, not ponying up seems like the right decision in terms of protecting taxpayer money. That may not necessarily hold. For example, Costa Rican officials reportedly refused to pay Russian hackers $20 million last year. In a fit of retribution, the cybercriminals brought down wide-reaching agencies for months to the tune of . By contrast, the relatively small city of Lafayette, Colorado, doled out a $45,000 ransom payment to avoid government entities shutting down and potentially greater losses. $30 million in losses Impact of Data Security Loss on Citizens A breach of government data is tantamount to citizens being exposed. The information held by tax collectors, permitting departments, and local canvassing boards can be leveraged against residents. Names, birthdates, addresses, and Social Security numbers are routinely stolen from devices and sold on the dark web. This and other sensitive information have also been used to dox political opponents in recent years. Municipal Services Disruptions The greatest threat for politicians and term-appointed officials may be getting ousted by voters. But for residents, critical services can be shut down for significant amounts of time. For example, a recent cyberattack impacted multiple water utility operations in Pennsylvania that used Israeli-made computer systems, according to reports. The FBI and Cybersecurity and Infrastructure Security Agency are investigating the attack that reportedly included anti-Israel messaging. “Our adversaries don’t care who runs critical infrastructure,” U.S. Rep. Christopher Deluzio . “If they can get in through the weakest link — and [if] that’s a small municipal authority or a private vendor — that’s what they’re going to target.” reportedly said These cyberattacks have also impacted other U.S. water authorities across the country. Although the nation-state hackers who orchestrated the infiltrations were not looking for a payoff, the recent incident highlights the vulnerability of essential services. Sophisticated cybercriminals can deploy similar tactics to shut down healthcare operations, voting systems, school computer networks, sewage treatment plants, and even the power grid. How to Fight Ransomware Attacks The importance of taking proactive measures to prevent ransomware attacks cannot be understated. The cost and upheaval for residents of local and state governments can have a devastating short-term and lasting effect. If there’s a silver lining to the fact hackers from halfway around the globe persistently try to harvest poorly defensed networks like low-hanging fruit, it’s that determined cybersecurity remains far less expensive than ransomware demands and losses. Governmental leaders have an opportunity to enlist the support of managed IT firms with cybersecurity expertise to implement best practices, consistent with recent mandates. federal data protection Cybersecurity Awareness Training An increased number of operations have begun offering cybersecurity awareness training to their entire staff in recent years. That effort has reduced the number of data breaches caused by to only a troubling 88 percent. That being said, cybersecurity awareness training gives frontline workers the skills and knowledge needed to identify phishing schemes, social engineering attacks, and other nefarious hacking methods. Not only does investing in awareness training help prevent ransomware attacks, but it also creates a cybersecurity culture. human error Multi-Factor Authentication Ranked among the most effective and simple security measures, multi-factor authentication requires network users to enter a code after inputting their username and password. By sending the code to a secondary resource, it prevents hackers from infiltrating governmental systems after learning someone’s login credentials. Zero Trust User Profiles The number of cyberattacks has increased almost exponentially in recent years because hackers are making bank. Decision-makers must proceed with the expectation that any system can be penetrated if a hacker has the time, tools, and skills. Zero trust policies reduce a hacker’s impact on services. These security measures can also prevent cybercriminals from reaching valuable and sensitive data. With zero trust, each legitimate user’s profile comes with data restrictions. Even if a hacker manages to gain access through an employee or official’s network credentials, the criminal also faces data access restrictions. Back Up Data Daily State legislatures appear to be moving forward with laws that ban local governments from paying ransom demands. Such laws make it imperative that every system’s data is backed up daily and taken offline. Without these sensitive and valuable digital assets, lengthy shutdowns and information recreation would result in massive losses. In cybersecurity circles, a successful ransomware attack is the sum of all fears. Once hackers seize control over municipal systems, they can put people in harm’s way by shutting down wide-reaching services. It’s mission-critical to have a risk assessment performed and use that information to harden governmental networks.

How Can State & Local Governments Fight Ransomware? 

কিভাবে রাজ্য এবং স্থানীয় সরকার Ransomware যুদ্ধ করতে পারে?

Wie können staatliche und lokale Regierungen Ransomware bekämpfen?

¿Cómo pueden los gobiernos estatales y locales luchar contra el ransomware?

Comment les États et les gouvernements locaux peuvent-ils lutter contre les ransomwares ?

राज्य और स्थानीय सरकारें रैनसमवेयर से कैसे लड़ सकती हैं?

州および地方自治体はランサムウェアとどのように戦うことができますか?

주 및 지방 정부는 어떻게 랜섬웨어에 맞서 싸울 수 있습니까?

Como os governos estaduais e locais podem combater o ransomware?

Как органы власти штата и местные органы власти могут бороться с программами-вымогателями?

Eyalet ve Yerel Yönetimler Fidye Yazılımlarıyla Nasıl Mücadele Edebilir?

Chính quyền tiểu bang và địa phương có thể chống lại ransomware như thế nào?

州和地方政府如何打击勒索软件？

This is the first part of a deeper dive into Ollama and things that I have learned about local LLMs and how you can use them for inference-based applications. In this post, you will learn about — How to use Ollama How to create your own model in Ollama Using Ollama to build a chatbot To understand the basics of LLMs (including Local LLMs), you can refer to my previous post on this topic . here First, Some Background In the space of local LLMs, I first ran into LMStudio. While the app itself is easy to use, I liked the simplicity and maneuverability that Ollama provides. To learn more about Ollama you can go . here tl;dr: Ollama hosts its own curated list of models that you have access to. You can download these models to your local machine, and then interact with those models through a command line prompt. Alternatively, when you run the model, Ollama also runs an inference server hosted at port 11434 (by default) that you can interact with by way of APIs and other libraries like Langchain. As of this post, Ollama has 74 models, which also include categories like embedding models. How to Use Ollama Ollama for the OS of your choice. Once you do that, you run the command to confirm it’s working. It should show you the help menu — Download ollama Usage:
  ollama [flags]
  ollama [command]

Available Commands:
  serve       Start ollama
  create      Create a model from a Modelfile
  show        Show information for a model
  run         Run a model
  pull        Pull a model from a registry
  push        Push a model to a registry
  list        List models
  cp          Copy a model
  rm          Remove a model
  help        Help about any command

Flags:
  -h, --help      help for ollama
  -v, --version   Show version information

Use "ollama [command] --help" for more information about a command. To use any model, you first need to “pull” them from Ollama, much like you would pull down an image from Dockerhub (if you have used that in the past) or something like Elastic Container Registry (ECR). Ollama ships with some default models (like which is Facebook’s open-source LLM) which you can see by running. llama2 ollama list Select the model (let’s say ) that you would like to interact with from the . You can now pull down this model by running the command phi Ollama library page ollama pull phi Once the download is complete, you can check to see whether the model is available locally by running — ollama list Now that the model is available, it is ready to be run with. You can run a model using the command — ollama run phi The accuracy of the answers isn’t always top-notch, but you can address that by selecting different models or perhaps doing some fine-tuning or implementing a RAG-like solution on your own to improve accuracy. What I have demonstrated above is how you can use Ollama models using the command line prompt. However, if you check the inference server that Llama has running you can see that there are programmatic ways of accessing this by hitting port 11434. If you wanted to use Langchain to access your Ollama model, you can use something like — from langchain_community.llms import Ollama
from langchain.chains import RetrievalQA

prompt = "What is the difference between an adverb and an adjective?"
llm = Ollama(model="mistral")
qa = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=retriever,
    return_source_documents=True,
)
response = qa(prompt) How to Create Your Own Model in Ollama You can also create your own model variant using the concept of in Ollama. For more parameters to configure in your Modelfile, you can look at these docs. Modelfile Example Modelfile — # Downloaded from Hugging Face https://huggingface.co/TheBloke/finance-LLM-GGUF/tree/main
FROM "./finance-llm-13b.Q4_K_M.gguf"

PARAMETER temperature 0.001

PARAMETER top_k 20

TEMPLATE """
{{.Prompt}}
"""

# set the system message
SYSTEM """
You are Warren Buffet. Answer as Buffet only, and do so in short sentences.
""" Once you have the Modelfile, you can create your model using ollama create arjunrao87/financellm -f Modelfile where is the name of your LLM model and would be replaced by your ollama.com username (which also acts as the namespace of your online ollama registry). At this point, you can use your created model like any other model on Ollama. financellm arjunrao87 You can also choose to push your model to the remote ollama registry. To make this happen, you need to Create your account on ollama.com Add a new model Have the public keys set up to allow you to push models from your remote machine. Once you have created your local llm, you can push it to the ollama registry using — ollama push arjunrao87/financellm 🦄 Now, let’s get to the good part. Using Ollama to Build a Chatbot During my quest to use Ollama, one of the more pleasant discoveries was this ecosystem of Python-based web application builders that I came across. can be used to build a full-fledged chatbot like ChatGPT. As their page says, Chainlit Chainlit is an open-source Python package to build production ready Conversational AI I walked through a few of the Chainlit tutorials to get a handle on what you can do with chainlit, which includes things like creating sequences of tasks (called “steps”), enabling buttons and actions, sending images, and all kinds of things. You can follow this part of my journey . here Once I got the hang of Chainlit, I wanted to put together a straightforward chatbot that basically used Ollama so that I could use a local LLM to chat with (instead of say ChatGPT or Claude). With less than 50 lines of code, you can do that using Chainlit + Ollama. Isn’t that crazy? Chainlit as a library is super straightforward to use. I also used Langchain for using and interacting with Ollama. from langchain_community.llms import Ollama
from langchain.prompts import ChatPromptTemplate
import chainlit as cl The next step is to define how you want the loading screen of the chatbot to look, by using the decorator of chainlit — @cl.on_chat_start @cl.on_chat_start
async def on_chat_start():
    elements = [cl.Image(name="image1", display="inline", path="assets/gemma.jpeg")]
    await cl.Message(
        content="Hello there, I am Gemma. How can I help you?", elements=elements
    ).send()
    ....
    .... The interface is what Chainlit uses to send responses back to the UI. You can construct messages with the simple key, and then you can embellish it with things like which, in my case, I have added an to show an image when the user first logs in. Message content elements Image The next step is to invoke Langchain to instantiate Ollama (with the model of your choice), and construct the prompt template. The usage of the is to mostly maintain the separation of user contexts and histories, which just for the purposes of running a quick demo, is not strictly required. cl.user_session Chain is a Langchain interface called that is used to create custom chains. You can read more about that . Runnable here @cl.on_chat_start
async def on_chat_start():
   ....
   ....
    model = Ollama(model="mistral")
    prompt = ChatPromptTemplate.from_messages(
        [
            (
                "system",
                "You are a knowledgeable historian who answers super concisely",
            ),
            ("human", "{question}"),
        ]
    )
    chain = prompt | model
    cl.user_session.set("chain", chain) Now, you have all the pieces to have a chatbot UI and accept user inputs. What do you do with the prompts the user provides? You will use the handler from Chainlit to do something with the message the user provided. @cl.on_message @cl.on_message
async def on_message(message: cl.Message):
    chain = cl.user_session.get("chain")
    msg = cl.Message(content="")
    async for chunk in chain.astream(
        {"question": message.content},
    ):
        await msg.stream_token(chunk)
    await msg.send() as the docs suggest “stream back chunks of the response async” which is what we want for our bot. chain.astream That is really it. A few imports, a couple of functions, a little bit of sugar, and you have a functional chatbot. For the full code, you can see my . GitHub 👏 If this content is interesting to you, hit that button or subscribe to my newsletter here → . It gives me the feedback that I need to do more or less of something! Thanks ❤️ https://a1engineering.beehiiv.com/subscribe Also published here

How to Use Ollama: Hands-On With Local LLMs and Building a Chatbot

কীভাবে ওল্লামা ব্যবহার করবেন: স্থানীয় LLM-এর সাথে হাত মিলিয়ে এবং একটি চ্যাটবট তৈরি করা

So verwenden Sie Ollama: Praktische Arbeit mit lokalen LLMs und Aufbau eines Chatbots

Cómo utilizar Ollama: práctica con LLM locales y creación de un chatbot

Comment utiliser Ollama : pratique avec les LLM locaux et création d'un chatbot

ओलामा का उपयोग कैसे करें: स्थानीय एलएलएम के साथ व्यावहारिक व्यवहार और एक चैटबॉट का निर्माण

Ollama の使用方法: ローカル LLM の実践とチャットボットの構築

Ollama 사용 방법: 현지 LLM 실습 및 챗봇 구축

Como usar o Ollama: prática com LLMs locais e construção de um chatbot

Как использовать Ollama: практический опыт работы с местными LLM и создание чат-бота

Ollama Nasıl Kullanılır: Yerel Yüksek Lisans Dereceleri ile Uygulamalı Çalışma ve Bir Chatbot Oluşturma

Cách sử dụng Ollama: Thực hành với LLM địa phương và xây dựng Chatbot

如何使用 Ollama：与当地法学硕士一起实践并构建聊天机器人

This paper is available on arxiv under CC 4.0 license. Authors: (1) Ali Ghanbari, Dept. of Computer Science, Iowa State University; (2) Deepak-George Thomas, Dept. of Computer Science, Iowa State University; (3) Muhammad Arbab Arshad, Dept. of Computer Science, Iowa State University; (4) Hridesh Rajan, Dept. of Computer Science, Iowa State University. Table of Links Abstract & Introduction Background Motivating Example Proposed Approach Supported DNN Bugs Evaluation Threats to Validity Related Work Conclusion, Acknowledgments & References VII. THREATS TO VALIDITY As with most empirical evaluations, we do not have a working definition of representative sample of DNN bugs, but we made efforts to ensure that the bugs we used in the evaluation is as representative as possible by making sure that our dataset has diverse examples of bugs from each subcategory of model bugs. ategory of model bugs. Many of the bugs obtained from StackOverflow did not come with accompanying training datasets. To address this issue, we utilized the dataset generation API provided by scikit-learn [64] to generate synthetic datasets for regression or classification tasks. We ensured that the errors described in each StackOverflow post would manifest when using the synthesized data points and that applying the fix suggested in the accepted response post would eliminate the bug. However, it is possible that this change to the training process may introduce new unknown bugs. To mitigate this risk, we have made our bug benchmark publicly available [36]. Another potential threat to the validity of our results is the possibility of bugs in the construction of deepmufl itself, which could lead to incorrect bug localization. To mitigate this, we make the source code of deepmufl publicly available for other researchers to review and validate the tool. Another threat to the validity of our results is the potential impact of external factors, such as the stochastic nature of the training process and the synthesized training/testing datasets, as well as system load, on our measurements. To address this, besides using deterministic seeds for dataset generation and splitting, we repeated our experiments with deepmufl three times. Similarly, we also ran other dynamic tools three times to ensure that their results were not affected by randomness during training. We did not observe any differences in effectiveness between the rounds for either deepmufl or the other studied techniques. Additionally, we repeated the time measurements for each round, and reported the average timing, to ensure that our time measurements were not affected by system load. Furthermore, judging whether or not any of the tools detect a bug requires manual analysis of textual description of the bugs and matching it to the tools; output messages which might be subject to bias. To mitigate this bias, we have made the output messages by the tools available for other researchers [36]. Lastly, deepmufl uses a threshold parameter to compare floating-point values (see §IV-C). In our experiments, we used the default value of 0.001 and ensured that smaller threshold values yield the same results.

Mutation-based Fault Localization of Deep Neural Networks: Threats to Validity

Stories, News & Mentions about LOC8

Loc8’s Stories on HackerNoon

Loc8's News & Mentions