The Zacks Style Scores offers investors a way to easily find top-rated stocks based on their investing style. Here's why you should take advantage.

Here's Why AutoZone (AZO) is a Strong Momentum Stock

Advance Auto Parts has underperformed compared to its competitors O'Reilly and AutoZone over the past decade. However, if we analyze its financial ratios this could be justified. The company's decline may have begun after a significant acquisition made in ...

Advance Auto Parts: Cheap For A Reason And An Uncertain Future

Frazer’s departure comes at a time of significant change for AutoZone. President and CEO Bill Rhodes recently announced he was relinquishing those roles and becoming executive chairman at the end of 2023. Philip B. Daniele III is set to take over as president and CEO.

Longtime AutoZone executive Preston Frazer departs after 17 years

Whether you're a value, growth, or momentum investor, finding strong stocks becomes easier with the Zacks Style Scores, a top feature of the Zacks Premium research service.

Here's Why AutoZone (AZO) is a Strong Value Stock

Taking into account the Volume and Open Interest on these contracts, it appears that whales have been targeting a price range from $1040.0 to $2750.0 for AutoZone over the last 3 months.

AutoZone Unusual Options Activity For October 30

AutoZone, Inc. retails and distributes automotive replacement parts and accessories in the United States, Mexico, and Brazil. The large-cap auto & home supply stores company is based in the United States, and over the last twelve months it has returned a ...

Here Are the Facts You Need to Understand AutoZone (AZO)

AutoZone Inc. is a renowned American retailer of automotive parts and accessories. With over 6,000 stores across the United States, Mexico, and Brazil, the company has become a household name in the automotive industry. To truly understand the success ...

Exploring the Success Story of AutoZone Inc.

AutoZone Inc. has emerged as a dominant player in the automotive retail sector, with its rapid growth and expansion leaving a lasting impact on the industry. Over the years, the company has successfully positioned itself as a one-stop shop for all ...

AutoZone Inc.: Its Impact and Influence on the Automotive Retail Sector

SEMA Show Promotions ALLDATA is offering a 15% discount on ALLDATA Repair and ALLDATA Collision. Subscribers can also save up to 20% on bundled solutions that include the #1 choice for unedited mechanical and collision OEM repair information, time-saving diagnostic tools, essential shop management software, and support services.

ALLDATA Ramps Up For SEMA: Connecting Shop Workflow To Boost Productivity

The second of two men involved in a scheme to steal and then sell auto parts from Austin's Autozone store has been sentenced. Jeremiah Coal Beaman, 24, was sentenced to two years supervised probation Wednesday in Mower County District Court for felony theft.

Second of two men convicted in Autozone thefts

AutoZone

autozone

I'm sure you've heard; DevOps is all the rage n insert fancy clothes and glass of champag e. No, but really. It's pretty popular right now. Interestingly enough, many organizations are hiring for it and have no idea what its purpose is. Some feel that it's an infrastructure role, others feel it's to look at CICD pipelines all day. But what does it truly mean? What's DevOps? Originally, DevOps was created and coined in 2009 by Patrick Debois. The purpose that he wanted to obtain with DevOps was to break down barriers between development and operations teams. If you've been in tech long enough, you know there used to be (and still is in some places) a mindset of: Give the code to the operations people so they can deploy it The code breaks the server The operations people don't want to deploy any changes because they want system uptime The developers want the code change because it's a new feature, hotfix, or component of an application that needs to be deployed Everyone is fighting There was a lot of back and forth. Both teams blamed each other and nothing got done. DevOps, originally, was supposed to stop that from happening. DevOps is the combination of bringing teams together and making workloads more efficient for everyone. It's Not A Title When you ask someone if DevOps is supposed to be a title, most engineers will tell you no. I'm in the category that it shouldn't be and instead, it should be a practice. However, that battle has been more or less lost. If you're still in the camp that it shouldn't be a title, then you're not wrong. DevOps, by definition, is a practice that should be within all engineering teams. It wasn't meant to be a specific team itself. It was meant to break down silos, not create a new one. It Is A Title Nowadays, you see titles all over the place. It's definitely an annoyance for folks that wanted DevOps to be what it was supposed to be, but the truth of the matter is times change. In a few years, the title will go away for something else. That's just how it goes. DevOps Engineer DevOps Engineer The thing to remember is this; the DevOps Engineer title is one of the highest-paying tech jobs in today's world, so I'd like for you to think about it like this: If it's the type of work you want to be doing and it pays what you want, who cares? Have fun and enjoy. Why It's Important Let's move away from the notion of what DevOps is supposed to be, and instead, think about what it is today. It's literally a job that does everything; development, operations, CICD, containers, orchestration, scalability, cloud... and the list doesn't stop there. The DevOps Engineer job today is one that is not a beginner-level role. It's very much an advanced, level 400 role. It's extremely important to keep that in mind. With that being said, the question becomes - why is it so important? In today's world, every company that isn't a software company is a software company. Let's take an auto-parts store like Auto Zone as an example. They're a car company, right? Well, here's the thing; they have an app, and a lot of people use that app. It's used to buy car parts, look car parts up, hold membership information, etc... That's a key part of the business. Because of that, they're now thinking more about software. Every organization, regardless of whether they're a tech company or not, is now always thinking about software. When thinking about software, management typically thinks about: How can we get features and the product into the hands of the customers faster How can the application and systems not go down How can we move faster When you think about it, that all falls under DevOps teams. The DevOps teams are pretty much the people that are running the company at this point. DevOps vs SRE I get asked this question a lot; Regardless of who you ask, you'll always get a different answer. What a lot of engineers do, including myself, is to follow the Google SRE handbook. If you haven't read the handbook, you can get it for free . When it comes to SRE and DevOps, DevOps is a subset of Site Reliability Engineering. I like to think of it as a child object of SRE. Instead of DevOps being a title, the practices of DevOps are embedded into the SRE role. what's the difference between DevOps and SRE? here Wrapping Up This blog post is the first of many in the DevOps/SRE Series. The goal of this series is to help engineers from all over the world break into DevOps and understand what's happening in the DevOps space. I believe you'll get a ton of value out of this and enjoy the process along the way. Thank you so much for reading! First published here

Should Anyone be Called a DevOps Engineer?

During “Hacker Week” in Las Vegas, thousands of information security professionals that include actual hackers, converge. It is best to be alert since there are bad actors who have rogue intentions. Finding victims can be easy when there is no awareness of the imminent threats. With that said, car hacking has become more commonplace in recent years, due to the increased integration with electronic systems that include the car’s own lock system. With keyless entry systems, it uses wireless or radio signals to unlock the car. These signals can in turn be intercepted and used to break into the car and even start it. One such technique is called SARA or Signal Amplification Relay Attack. All roads lead to DEF CON 2018 (Las Vegas, NV) This keyless entry hack is probably one of the simplest out there. This follows a similar principle to “relays” which transmit an RFID signal across a longer distance. Keyless entry systems use a “handshake” signal that sends a signal from the key fob to the car’s lock controller unit. When the fob is within proximity of the car, the controller unit detects it and unlocks the car automatically. The radio transmitter relay device works on that principle using two devices. One device must be placed next to the car, while the other must be within close proximity to the car owner’s key fob. A signal is boosted from the car to the fob to trick it in a sense by sending the signal from the device next to the car to the device that is near the key fob. Then the signal is copied rather than decrypted and can be used to not only open the car, but to start the car as well. So it doesn’t even try to decrypt the signal, just copy and use. It’s like intercepting someones private key. There are vulnerable car models, mostly European. There is no fix or update to download to fix the problem unfortunately. Covering your key fob with foil or a faraday cage certified box works, but to the owner’s inconvenience. You can ask your car dealer if the car model you have is vulnerable to this hack. They may or may not know, so consulting the auto manufacturer might be best. Old school solution I would suggest is to get a anti-theft lock on the car’s steering wheel or brake pedal. Those are not electronic and use actual keys. Other solutions include putting the key fob in a shielded pouch or a signal blocking fob holder. Anti-theft steering wheel lock, The Club, is one of the best ways to secure against SARA (Source: Autozone) In 2016, security researchers at the Munich-based automobile club ADAC their findings of attacks they performed to test the vulnerability. They did this to 24 vehicles from 19 different manufacturers. published Here is a list of some cars affected: https://www.forbes.com/sites/thomasbrewster/2016/03/21/audi-bmw-ford-thief-car-hacking/#2cccd9514f1e This information is given for educational and reference purposes only. Hacking for malicious purposes is an illegal activity which is punishable by the law. Note:

Signal Amplification Relay Attack (SARA)

Recently, we discussed how developers could make use of the . In that post, we shared a simple Node.js script that would call one of the APIs using a file stored in Azure. Photoshop API It was simple — get an access token, start an API job with an input document, poll for completion, and then check the result. Simple is good though as it means it’s easy to integrate into custom workflows. In today’s post, we’ll do just that. Our Workflow Let’s begin by defining what our workflow is going to do. Imagine we are using a cloud storage provider, in this case, Dropbox, to store photos. Our workflow is going to monitor this folder and trigger when new pictures are added. When the picture is added, we will grab the file and send it to an endpoint that runs the Lightroom feature. This feature attempts to correct exposure, contrast, and other issues in photos. “AutoTone” As an example (that we stole right from the ), here’s a before and after showing the impact of the corrections: docs Once the API is done, we will then store the result in folder in Dropbox. We could overwrite the original, but most likely, people will want both copies so they can make a final check to see which they prefer. another The Worfklow Platform For our workflow, we will use . Pipedream is a low-code/no-code solution for building generic workflows. It’s in the same space as Microsoft PowerAutomate and Workfront Fusion. (And you can expect to see examples from us soon on those platforms as well.) Pipedream Pipedream really helps developers by making the more difficult, or even boring, aspects of a project “plug and play.” As an example, when defining what starts a workflow, a trigger, Pipedream comes with a huge set of pre-built code blocks. When we start demonstrating how we built our workflow, you’ll see that in action. Pipedream has a free tier, so those of you reading who want to follow along can do so after signing up. If you’ve never used Pipedream before, check out their excellent for an introduction to how it works. They also have excellent . Finally, your friendly author here has about Pipedream as well. Pipedream University docs written With that out of the way, let’s get building! Step One — The Trigger Pipedream workflows start with a trigger that represents the “event” that should kick off our process. Pipedream has many, of these triggers built-in (and you can write your own), and luckily, a “New File” in Dropbox trigger is supported: many After selecting the “New File” trigger, you are given a simple interface to configure it: On top is the authentication aspect. Here, you can connect Pipedream to your Dropbox account. Best of all, once you’ve done that one time, you can reuse that connection in multiple workflows. Next, make a note of the Path value. You can type in here, and Pipedream will attempt to autocomplete based on your account, or simply enter a path. We’re going to use as the folder that expects to get images. /PSAPI_Input The next two settings can be ignored, but the final setting, , should be toggled to true. We're going to need that link so we can tell the API how to fetch the data. Include Link Here’s the final configured trigger for our workflow: To recap, at this point, we’ve configured the workflow to fire automatically as soon as a file is added to a particular folder in our Dropbox account. Step Two — Get an Upload URL When the Photoshop API runs, it expects at minimum two things — an input URL and an output URL. Basically, where to read its input and where to store the result. Our input is going to be the new file added to Dropbox. Our output is going to be the location of the image corrected by Lightroom. To support this, we need to ask Dropbox to generate a special URL that can be used to store data. Pipedream has a lot of Dropbox actions built-in but unfortunately, does not have this particular one. Fortunately, Pipedream does let you create a step with custom code where it’s already handled the authentication for you. Remember that in the trigger, we specified an existing Dropbox account. Because we did this, we can then write code and let Pipedream handle authentication. By consulting the , we find the endpoint which is exactly what we need. Dropbox API get_temporary_upload_link In Pipedream, we add a new step and select “Use any Dropbox API in Node.js.” This gives us boilerplate code hitting one sample endpoint: https://gist.github.com/cfjedimaster/867a554f8f046ac357c89ae156441aae?embedable=true#file-script-js Most importantly — note the authentication information is automatically provided. All we need to do then is to edit the endpoint and set our input: https://gist.github.com/cfjedimaster/cf4932ba1d66887a7a75e3a5e9169d0e?embedable=true#file-script-js Note we are using a path that’s a different folder, . The value after that, , demonstrates using information from earlier in our workflow, specifically the filename of the event that triggered our workflow, and the name of the file itself. /PSAPI_Output ${steps.trigger.event.name} The code ends by returning the result of the API call, which in our case, is going to be a special URL we can use with our API call. Step Three — Getting an Access Token In our , we discussed how to get credentials for the Photoshop API and how then to use them in code to get an access token. In Pipedream, we can add a step to our workflow to run custom code. previous blog post You saw that in the previous step when we hit the Dropbox API. Pipedream supports both Node.js and Python so you’ve got a few options there. We will add a new code step and name it . getAccessToken This step will be responsible for using our credentials to generate a JWT and exchange that for an access token. In that previous blog post, the code made use of the package to simplify the process. However, this package does not work as an ES6 import which Pipedream supports. Luckily, we can swap out to another NPM package, . Let’s take a look at the code: @adobe/jwt-auth jsonwebtoken https://gist.github.com/cfjedimaster/54fbfc2c4a8e90ffda5f6007ddb13714?embedable=true#file-script-js So a couple of things here. First, every Node Pipedream code step uses a form like so: https://gist.github.com/cfjedimaster/a12dd06e92a801ae7572616709f04303?embedable=true#file-script-js The function is called automatically, and passed data from any previous steps as well as a handler ( ) for other operations we won't need. Basically, we will put our imports on top and our logic inside. run $ You can see a set of variables being copied from the environment as — not surprisingly — Pipedream lets us define custom environment variables as well. The next block of code generates our JWT. This is mostly boilerplate, but pay special attention to the part. This variable, , is what sets the scope for our token and is required to work with the APIs. jwtOptions "https://ims-na1.adobelogin.com/s/ent_ccas_sdk": true, After the JWT is created, it can be sent to a generic Adobe endpoint to generate an access token. The final bit of logic is to return that token. If you remember in the previous step, anything we return can be used later. You’ll see this in action soon. Step Four — Calling the Lightroom Autotone API Now, it’s time to get down to business. Our trigger gave us a link to the new image. The next code step generated a link for us to upload the final result. We then got an access token. We’ve got everything needed to start the process. Once again, we’ll add a Node.js step to our workflow. Here it is in action. https://gist.github.com/cfjedimaster/605a25a51602bd91eaeafb0bbd68d02a?embedable=true#file-script-js The requires a few parameters, in this case, an input and output value. In our case, we pass in the link from the trigger and the special upload URL generated earlier. Autotone API And that’s it! The result of this call is a link to the job which we return at the end. Step Five — Do Nothing Ok, not exactly , but here’s an interesting question. This entire workflow runs automatically with no human interaction. The previous step kicks off a process that, when done, will save the result to Dropbox. Do we need to do anything else? Not really. nothing It’s absolutely possible the API may fail for some reason. It’s possible something else could go wrong as well. It’s also possible we may want to alert someone about the change, perhaps via email. Honestly, it’s up to you. In our sample workflow, we decided to simply check the job and wait for it to finish. Here’s that code step, and it’s pretty similar to our previous blog post. We check the job, wait, and check it again. https://gist.github.com/cfjedimaster/207617f3a824c5cb6ef22f43983a9a1b?embedable=true#file-script-js This is where we end the workflow, but we could, and probably should, add logic to check the result of the job and do something. Perhaps on a good result, we do nothing, but on error, we then send an email. (And by the way, Pipedream makes sending emails ludicrously easy.) What’s nice though is that we can decide that later. One really nice feature of Pipedream is that it makes it easy to check when workflows have run. For example, here’s a list of past executions: The errors you see there came from me playing with the API and figuring out how it worked. You can also click on any of them and see the data that flowed throughout it. The Result With the workflow in place, we uploaded a new image to a Dropbox folder, watched the workflow firing in an open tab, and when done, checked the result. Here’s before: And here’s after: The result is crisper, and absolutely an improvement! You can create your own copy of my workflow here: . If you want to learn more, visit our , and share what you’ve built! https://pipedream.com/new?h=tch_3xxfJA docs Also published here

How to Automate Image Workflows With the Photoshop API

ফটোশপ এপিআই দিয়ে কীভাবে ইমেজ ওয়ার্কফ্লো স্বয়ংক্রিয় করবেন

So automatisieren Sie Bild-Workflows mit der Photoshop-API

Cómo automatizar flujos de trabajo de imágenes con la API de Photoshop

Comment automatiser les flux de production d'images avec l'API Photoshop

फ़ोटोशॉप एपीआई के साथ छवि वर्कफ़्लो को स्वचालित कैसे करें

Photoshop API を使用して画像ワークフローを自動化する方法

Photoshop API를 사용하여 이미지 작업 흐름을 자동화하는 방법

Como automatizar fluxos de trabalho de imagem com a API do Photoshop

Photoshop API ile Görüntü İş Akışlarını Otomatikleştirme

Cách tự động hóa quy trình làm việc với hình ảnh bằng API Photoshop

如何使用 Photoshop API 自动化图像工作流程

GraphQL is an API technology that is rapidly gaining popularity among thousands of enterprises around the world. It was built to improve many aspects of REST, one of them being that GraphQL provides a native way to expose an API schema. This schema makes it easier than ever to generate API documentation with little effort. Introducing Magidoc Magidoc is an open source tool that can be used to easily autogenerate static GraphQL documentation for any GraphQL API, either from SDL files or from a live endpoint using the introspection query. Not only can you use Magidoc to generate beautiful and easy to understand API documentation out of the box, but you can also provide custom pages using markdown. These pages allow you to present your API however you want. For instance, you could describe different concepts, examples, flows, URLs, etc. Getting started Schema (SDL) First, we need a schema. For the sake of this demonstration, let’s use a simple TODO application schema. In a file named , we will put the following code. schema.graphqls type Todo {
  id: ID
  name: String
  complete: Boolean
}

input TodoInput {
  todoId: ID
  name: String
  complete: Boolean
}

type Query {
  """
  Returns all TODOs 
  """
  todos: [Todo]
  """
  Return a specific TODO by ID. 
  """
  todo(todoId: ID): Todo
}

type Mutation {
  """
  Creates a TODO and returns it.
  """
  createTodo(input: TodoInput!): Todo
  """
  Updates a TODO or returns an error if it does not exist.
  """
  updateTodo(input: TodoInput!): Todo
  """
  Toggles a TODO or returns an error if it does not exist.
  """
  toggleTodo(todoId: ID!): Todo
  """
  Deleted a TODO or returns an error if it does not exist.
  """
  deleteTodo(input: TodoInput!): [Todo]
} Magidoc configuration Then, we need a Magidoc configuration file. Magidoc uses configuration as code, which means that the configuration is nothing more than a Javascript file. This allows you to implement logic in it. For our example, let’s write the following configuration in a file called : magidoc.mjs export default {
  introspection: {
    type: 'sdl',
    paths: ['./schema.graphqls'],
  },
  website: {
    template: 'carbon-multi-page',
    options: {
      appTitle: 'Medium Article',
      appLogo: 'https://seeklogo.com/images/P/Pokemon-logo-497D61B223-seeklogo.com.png',
      pages: [{
        title: 'Medium Article',
        content: `
# Medium Article
Congratulations! You've successfully completed the Magidoc tutorial.
## Where to go next?
- Star the project on [GitHub](https://github.com/magidoc-org/magidoc) 
- Read the [documentation](https://magidoc.js.org/introduction/welcome)
`
      }],
    },
  },
} In this example, we load our schema from an SDL file. We also configure different website options, like the , and a custom page that contains markdown that will be rendered by Magidoc in the output website. appTitle appLogo Magidoc supports advanced markdown features like tables, ordered and unordered lists, inline HTML and much more. Build it Finally, to build our website, we’ll execute the following commands: npm install --global @magidoc/cli@latest
magidoc generate
magidoc preview These commands will install Magidoc, generate the website and then preview the output locally. And there you have it! A static GraphQL API documentation. Conclusion Magidoc is a powerful tool that can help you build superior GraphQL documentation very easily. This tutorial only scratches the surface of all that is possible to do with Magidoc. Many more advanced features exist, like a development server with hot-reload, the ability to provide custom assets (images or videos), full customization of the template using Svelte & Svelte-Kit, and many more built-in customization. Make sure to check out the documentation to learn how you can turn your GraphQL schema into branded documentation website for your company, and have a look at the if you’re interested in contributing. Github repository Thank you for reading!

Autogenerate Your GraphQL Documentation With Magidoc

TLDR (30s) To quickly get your own customizable Webhook URL, simply this . You can change the name of the project if you'd like, as it's reflected in the webhook URL that's generated. Fork Source in Autocode Once you've created the Fork you'll be brought into the Autocode editor. Click on the blue Deploy button at the bottom left corner of the editor. Once it's deployed, open the file to view the live Webhook URL at the bottom of the editor. functions/__main__.js That's it! You can add whatever custom handling logic you'd like to the webhook at anytime, and simply click deploy again! : Make sure you include the at the end of the url otherwise it will be redirected and the payload will be dropped. Note / --url https://YOUR_USERNAME.api.stdlib.com/my-webhook@dev/ \
    --header 'content-type: application/json' \
    --data '{
  "some_data": "This is sample data",
  "more_data": "More sample data"
}' --url 'https://YOUR_USERNAME.api.stdlib.com/my-webhook@dev/?some_data=%22This%20is%20sample%20data%22&more_data=%22More%20sample%20data%22' $ curl --request POST \ # OR $ curl --request GET \ Introduction Often when working on projects that involve integrating different tools together or syncing data between different services, you may find yourself utilizing . A lot of tools/services allow you to set a webhook URL that they can then push data to based on some triggers. The webhook server behind that URL can then perform custom logic with that data. webhooks Sounds pretty straightforward right? However, you'll realize you have to provision a new server, develop and deploy a web app, and worry about other administrative tasks such as maintenance and scalability. Not to mention, every time you want to make changes or test different payloads, you'd need to go through the deployment process again. This adds a lot of hurdles just to perform a simple task of receiving and handling data from an external service. We get a lot of questions about setting up webhooks at , and I think it's the easiest way to get started and have a live webhook URL in (literally) seconds. I built a that you can simply fork and deploy to get your own webhook URL in no time! Autocode Source in Autocode Your webhook is deployed on top of serverless technology. That means it will scale for you without any need for administrative efforts on your end. How It Works When your webhook is deployed on Autocode, the endpoint listens to incoming requests. It accepts both and requests. The parameters passed in from either the request body or querystrings are parsed out and included in the object. is a magic parameter that we populate automatically. GET POST context.params context It must be the last parameter in the list of parameters you define in your function signature. You can access the headers or the actual request body and other useful data from within the object: context .exports = (context) => { result = {}; .log( , context.params); .log( , context.http.headers); .log( , context.http.body); result;
}; /**
* An HTTP endpoint that acts as a webhook for HTTP(S) request event
* @returns {object} result Your return value
*/ module async let console 'params:' console 'headers:' console 'body:' return You can also pass in named parameters with type checking included out of the box based on the specification. FunctionScript Simply include the named parameter as an argument in the function and update the comment above the function defining the name and type of that parameter it should expect: .exports = (name = , age, context) => { result = {}; .log( , context.params); .log( , context.http.headers); .log( , context.http.body); result;
}; /**
* An HTTP endpoint that acts as a webhook for HTTP(S) request event
* @param {string} name
* @param {number} age 
* @returns {object} result Your return value
*/ module async "Bob" let console 'params:' console 'headers:' console 'body:' return Testing with Payloads You can test your webhook URL before deploying it from within the Autocode editor. Press on the at the top of the endpoint file: Edit Test Event Payload That will open up the payload editor where you can enter a JSON formatted payload for testing: Once you've finished setting a test payload and saved it, click on the green button at the bottom right corner of the editor. Run Test Event That will then open up a console displaying any logs or errors you may have: Deploying your Webhook When you're ready to deploy your webhook URL and start listening to incoming events, all you need to do is press on the blue button at the bottom left corner of the editor: Deploy Once it's deployed, the URL displayed is now ready to handle events from any external service. You can also view real time logs by clicking on the View Logs button in the same corner of the editor. : Make sure you include the at the end of the URL otherwise it will be redirected and the payload will be dropped. Note / That's It! Thanks for checking out this post! Hope it helped, if you have any questions please feel free to reach out to me at . I'd love to hear about what you're building! You can also follow the Autocode team on Twitter for more updates . yusuf@autocode.com @AutocodeHQ Yusuf is a software engineer at Autocode . Previously published at https://dev.to/ymusleh/setup-a-custom-webhook-url-in-30-seconds-with-autocode-3ce9

How To Create a Custom Webhook URL Using Autocode

A frame for long-term impact [People] make their own history, but they do not make it just as they please; they do not make it under circumstances chosen by themselves, but under circumstances directly found, given and transmitted from the past. – Karl Marx (quoted by Levi Bryant) Cognitive biologists Maturana and Valera argue that the defining quality of living things is that they are “autopoietic.” literally means self-creation. Living things, Maturana and Valera explain, are able to regenerate their own parts, like how the cells of an animal die and regenerate or how a species reproduces. Autopoiesis Autopoiesis is an intriguing lens through which to understand the aspirations of tech companies. To examine what it means for a tech company to be autopoietic, let’s consider two systems on which it depends: its product and its customers. An autopoietic company maintains a circular loop where the team builds the product, customers use it, and the team is paid to keep iterating. This is otherwise described as product-market fit. Startups are not born autopoietic — they are bootstrapped by investment and the passion of their founders. If these elements dry up before product-market fit is achieved, the team stops building and the company ceases. Startups who achieve autonomous life remain vulnerable like organisms. The departure of a leader, a shift in the technical landscape, or the collapse of a market can lead to a company’s demise. The most ambitious founders want more than a brief period of success: they envision autopoietic institutions that will thrive after their departure, riding waves of technological and social change. To achieve longevity, companies must behave more like species than organisms. Traits for survival must evolve across generations in the midst of environmental flux. Great companies maintain their circular loop of creation as employees are fired and hired, as customers are acquired and lost, and as technology is refactored. They preserve life and identity while their elements radically change. Companies are often advised to define their “DNA.” Genetics is an apt metaphor for the passing of values to new hires. However, genetics is not the only mechanism for passing down survival advantages. In the , philosopher Levi Bryant writes: Democracy of Objects … it’s worth recalling that Darwin nowhere specifies what the mechanism of inheritance is, only that in order for natural selection to take place there must be inheritance. There is thus no reason to suppose that genes alone are the sole mechanism of inheritance. Organisms alter their environments to enhance their future prospects. There is a class of animals known as who change their environment to suit their purposes. Beavers build dams and birds assemble nests. niche constructors For some species, survival is predicated on the non-genetic creations of their predecessors. Bryant quotes developmental systems theorists, Griffiths and Gray: Certain aphid species reliably pass on their endosymbiotic Buchnera bacteria from the maternal symbiont mass to either eggs or developing embryo. The bacteria enable their aphid hosts to utilize what would otherwise be nutritionally unsuitable host plants. Aphids that have been treated with antibiotics to eliminate the bacteria are stunted in growth, reproductively sterile, and die prematurely. Bryant explains: The point here is that the Buchnera bacteria is not a part of the aphid’s genome, but nonetheless plays a significant role in the development of the phenotype. Far from the genes already containing information in the form of a blueprint of what the organism will turn out to be, genes are one developmental causal factor among a variety of others. The notion of non-genetic inheritance suggests that organizations can do more than pass down corporate values to new employees through training and culture. Companies can plant survival advantages in their environment; that is, within systems that exist independently of the team members themselves. Here’s a simple example from my startup. We connected our post-purchase customer survey with our Slack communication system. Whenever a customer submits the survey, the Typeform app posts the response to a Slack channel where everyone sees it. Notifications are sent if the Net Promoter Score is beneath a certain threshold. The result is that a baseline of real-time customer awareness is automatically provided for new employees. New team members don’t need to learn, “we value customer feedback” and then consciously seek it out. Instead, customer feedback is in the environment. Employees “inherit” an advantage out the gate that doesn’t require DNA transfer. already there The circular loop of product creation is bi-directional. Long lasting products must be designed to perturb the team when something needs to be changed. Not only must the team build the product, but the product must build the team. Constructing environmental survival advantages helps companies increase longevity through autopoiesis. However, a system’s achievement of autopoiesis isn’t necessarily good for the world at large. Maturana and Valera argue that the goal of autopoietic systems is to maintain their circular loops of self-creation. Regardless of the mission and intentions of the founders, the most successful companies take on a life of their own, a life who’s overall impact on connected systems is unpredictable. only I’m struck by how startups state their intention to “change the world” or “dent the universe.” Changes and dents, of course, can have both positive and negative impacts. Autopoietic systems created climate change and fake news. Note: Thanks to Jordan Peacock for nudging me down the autopoiesis road and pointing me to Levi Bryant.

Autopoietic Product Thinking

Table of Links Abstract and Introduction
SylloBio-NLI
Empirical Evaluation
Related Work
Conclusions
Limitations and References A. Formalization of the SylloBio-NLI Resource Generation Process B. Formalization of Tasks 1 and 2 C. Dictionary of gene and pathway membership D. Domain-specific pipeline for creating NL instances and E Accessing LLMs F. Experimental Details G. Evaluation Metrics H. Prompting LLMs - Zero-shot prompts I. Prompting LLMs - Few-shot prompts J. Results: Misaligned Instruction-Response K. Results: Ambiguous Impact of Distractors on Reasoning L. Results: Models Prioritize Contextual Knowledge Over Background Knowledge M Supplementary Figures and N Supplementary Tables D Domain-specific pipeline for creating NL instances E Accessing LLMs To access these LLMs, we use the Mistral AI (mistral), and the open-source weights of the remaining models, available at the HuggingFace Hub[5] repositories: • mistralai/Mistral-7B-v0.1 • mistralai/Mistral-7B-Instruct-v0.2 • mistralai/Mixtral-8x7B-Instruct-v0.1 • google/gemma-7b • google/gemma-7b-it • meta-llama/Meta-Llama-3-8B • meta-llama/Meta-Llama-3-8B-Instruct • BioMistral/BioMistral-7B The pretrained LLM weights are used through the transformers[6] python library. All models were loaded with standard configurations and their respective default tokenizers, using the AutoModelForCausalLM and AutoTokenizer classes. Additionally, the models were loaded with the options device_map=“auto", torch_dtype=“auto" attn_implementation=“flash_attention_2" and offload_buffers=True to make the best use of GPU resources available. For the instruction models, the inputs were passed through each model’s chat template (with tokenizer.apply_chat_template), so that they would follow the appropriate prompt format. Responses were cleaned of special symbols for evaluation. Table 3 contains the relevant characteristics of all analyzed models. Authors:
(1) Magdalena Wysocka, National Biomarker Centre, CRUK-MI, Univ. of Manchester, United Kingdom;
(2) Danilo S. Carvalho, National Biomarker Centre, CRUK-MI, Univ. of Manchester, United Kingdom and Department of Computer Science, Univ. of Manchester, United Kingdom;
(3) Oskar Wysocki, National Biomarker Centre, CRUK-MI, Univ. of Manchester, United Kingdom and ited Kingdom 3 I;
(4) Marco Valentino, Idiap Research Institute, Switzerland;
(5) André Freitas, National Biomarker Centre, CRUK-MI, Univ. of Manchester, United Kingdom, Department of Computer Science, Univ. of Manchester, United Kingdom and Idiap Research Institute, Switzerland. This paper is available on arxiv under CC BY-NC-SA 4.0 license. [5] https://huggingface.co [6] https://huggingface.co/docs/transformers/ Table of Links Abstract and Introduction SylloBio-NLI Empirical Evaluation Related Work Conclusions Limitations and References Abstract and Introduction Abstract and Introduction SylloBio-NLI SylloBio-NLI Empirical Evaluation Empirical Evaluation Related Work Related Work Conclusions Conclusions Limitations and References Limitations and References A. Formalization of the SylloBio-NLI Resource Generation Process A. Formalization of the SylloBio-NLI Resource Generation Process B. Formalization of Tasks 1 and 2 B. Formalization of Tasks 1 and 2 C. Dictionary of gene and pathway membership C. Dictionary of gene and pathway membership D. Domain-specific pipeline for creating NL instances and E Accessing LLMs D. Domain-specific pipeline for creating NL instances and E Accessing LLMs F. Experimental Details F. Experimental Details G. Evaluation Metrics G. Evaluation Metrics H. Prompting LLMs - Zero-shot prompts H. Prompting LLMs - Zero-shot prompts I. Prompting LLMs - Few-shot prompts I. Prompting LLMs - Few-shot prompts J. Results: Misaligned Instruction-Response J. Results: Misaligned Instruction-Response K. Results: Ambiguous Impact of Distractors on Reasoning K. Results: Ambiguous Impact of Distractors on Reasoning L. Results: Models Prioritize Contextual Knowledge Over Background Knowledge L. Results: Models Prioritize Contextual Knowledge Over Background Knowledge M Supplementary Figures and N Supplementary Tables M Supplementary Figures and N Supplementary Tables D Domain-specific pipeline for creating NL instances E Accessing LLMs To access these LLMs, we use the Mistral AI (mistral), and the open-source weights of the remaining models, available at the HuggingFace Hub[5] repositories: • mistralai/Mistral-7B-v0.1 • mistralai/Mistral-7B-Instruct-v0.2 • mistralai/Mixtral-8x7B-Instruct-v0.1 • google/gemma-7b • google/gemma-7b-it • meta-llama/Meta-Llama-3-8B • meta-llama/Meta-Llama-3-8B-Instruct • BioMistral/BioMistral-7B The pretrained LLM weights are used through the transformers[6] python library. All models were loaded with standard configurations and their respective default tokenizers, using the AutoModelForCausalLM and AutoTokenizer classes. Additionally, the models were loaded with the options device_map=“auto", torch_dtype=“auto" attn_implementation=“flash_attention_2" and offload_buffers=True to make the best use of GPU resources available. For the instruction models, the inputs were passed through each model’s chat template (with tokenizer.apply_chat_template), so that they would follow the appropriate prompt format. Responses were cleaned of special symbols for evaluation. Table 3 contains the relevant characteristics of all analyzed models. Authors: (1) Magdalena Wysocka, National Biomarker Centre, CRUK-MI, Univ. of Manchester, United Kingdom; (2) Danilo S. Carvalho, National Biomarker Centre, CRUK-MI, Univ. of Manchester, United Kingdom and Department of Computer Science, Univ. of Manchester, United Kingdom; (3) Oskar Wysocki, National Biomarker Centre, CRUK-MI, Univ. of Manchester, United Kingdom and ited Kingdom 3 I; (4) Marco Valentino, Idiap Research Institute, Switzerland; (5) André Freitas, National Biomarker Centre, CRUK-MI, Univ. of Manchester, United Kingdom, Department of Computer Science, Univ. of Manchester, United Kingdom and Idiap Research Institute, Switzerland. Authors: Authors: (1) Magdalena Wysocka, National Biomarker Centre, CRUK-MI, Univ. of Manchester, United Kingdom; (2) Danilo S. Carvalho, National Biomarker Centre, CRUK-MI, Univ. of Manchester, United Kingdom and Department of Computer Science, Univ. of Manchester, United Kingdom; (3) Oskar Wysocki, National Biomarker Centre, CRUK-MI, Univ. of Manchester, United Kingdom and ited Kingdom 3 I; (4) Marco Valentino, Idiap Research Institute, Switzerland; (5) André Freitas, National Biomarker Centre, CRUK-MI, Univ. of Manchester, United Kingdom, Department of Computer Science, Univ. of Manchester, United Kingdom and Idiap Research Institute, Switzerland. This paper is available on arxiv under CC BY-NC-SA 4.0 license. This paper is available on arxiv under CC BY-NC-SA 4.0 license. available on arxiv [5] https://huggingface.co [6] https://huggingface.co/docs/transformers/

Accessing and Utilizing Pretrained LLMs: A Guide to Mistral AI and Other Open-Source Models"

Speculative decoding is an advanced AI inference technique that is gaining traction in natural language processing (NLP) and other sequence generation tasks. It addresses one of the most significant challenges in deploying large-scale models: balancing computational efficiency with the quality of generated outputs. Models like GPT-3 and GPT-4 have set new benchmarks in AI capability but are computationally expensive, especially for real-time applications such as chatbots, translation systems, and interactive assistants. Speculative decoding offers a clever solution by introducing a two-model system: a smaller, faster draft model and a larger, more accurate target model. This approach reduces latency without compromising the quality of the generated sequences. At its core, speculative decoding is a two-step process. First, a lightweight draft model generates a sequence of tokens quickly. This model is typically a distilled version of the target model or another smaller model trained for speed. The draft model's output is not final but serves as a proposal. The second step involves the larger, more accurate target model, which evaluates the draft model’s tokens. The target model either accepts the proposed tokens if they meet a confidence threshold or refines them if they do not. This process allows the system to leverage the efficiency of the draft model while maintaining the precision of the target model. The reason speculative decoding is particularly appealing lies in its ability to reduce the computational burden of the larger model. By delegating the initial token generation to the draft model, the target model operates selectively, focusing only on validation or correction rather than generating every token from scratch. This division of labor significantly reduces inference latency and resource consumption, making it a preferred technique for real-time applications. The technique works well in scenarios where speed is critical, and the quality of generated outputs cannot be compromised. For instance, in chat-based applications, users expect near-instantaneous responses. Speculative decoding ensures that the system generates text quickly while retaining the nuanced understanding of the larger model. Similarly, in real-time translation systems, where delays can disrupt communication, speculative decoding provides a practical way to meet latency constraints. To understand speculative decoding more concretely, let us consider a code implementation. Below is an example that demonstrates how speculative decoding could be implemented using PyTorch and Hugging Face's Transformers library. This implementation involves a draft model (a smaller, faster version like DistilGPT-2) and a target model (a larger, more accurate model like GPT-2). from transformers import AutoModelForCausalLM, AutoTokenizer

# Load the draft (smaller) and target (larger) models

draft_model_name = "distilgpt2"  # Smaller, faster model 

target_model_name = "gpt2"      # Larger, more accurate model

draft_tokenizer = AutoTokenizer.from_pretrained(draft_model_name) draft_model = AutoModelForCausalLM.from_pretrained(draft_model_name)

target_tokenizer = AutoTokenizer.from_pretrained(target_model_name) target_model = AutoModelForCausalLM.from_pretrained(target_model_name)

def speculative_decode(prompt, max_length=50, threshold=0.9): """ Performs speculative decoding using a draft model and a target model.

Args:
    prompt (str): The input text to the model.
    max_length (int): The maximum length of the generated sequence.
    threshold (float): The confidence threshold for the target model to accept tokens.

Returns:
    str: The generated text sequence.
"""
# Step 1: Generate tokens using the draft model
draft_inputs = draft_tokenizer(prompt, return_tensors="pt")  # Tokenize the prompt
draft_outputs = draft_model.generate(draft_inputs.input_ids, max_length=max_length)  # Generate draft tokens
draft_tokens = draft_tokenizer.decode(draft_outputs[0], skip_special_tokens=True)  # Decode draft tokens to text

# Step 2: Verify tokens using the target model
target_inputs = target_tokenizer(draft_tokens, return_tensors="pt")  # Tokenize the draft output for the target model
target_logits = target_model(**target_inputs).logits  # Get logits (un-normalized probabilities) from the target model

# Step 3: Calculate confidence scores for each token
probs = target_logits.softmax(dim=-1)  # Convert logits to probabilities
confidence = probs.max(dim=-1).values.mean().item()  # Calculate the average confidence score across all tokens

# Step 4: Decide whether to accept or refine tokens
if confidence >= threshold:  # If confidence exceeds the threshold
    return draft_tokens  # Accept the draft tokens
else:  # Otherwise, refine the sequence using the target model
    refined_outputs = target_model.generate(target_inputs.input_ids, max_length=max_length)
    return target_tokenizer.decode(refined_outputs[0], skip_special_tokens=True)  # Return the refined sequence


prompt = "The future of AI is" output = speculative_decode(prompt, max_length=20) print(output) In this implementation, the speculative decoding process begins with the draft model generating a sequence of tokens. These tokens are then passed to the target model, which calculates the confidence for each token. If the average confidence exceeds a pre-defined threshold, the tokens are accepted as is. Otherwise, the target model refines the sequence to ensure output quality. This code includes detailed comments explaining each step, from tokenizing the input for the draft model to generating and validating tokens with the target model. The threshold parameter can be adjusted based on the application’s tolerance for speed versus accuracy trade-offs. One of the primary challenges in implementing speculative decoding is training the draft model. The draft model must align closely with the target model in terms of predictions, as significant discrepancies can reduce the efficiency of the process. For example, if the draft model frequently proposes incorrect tokens, the target model spends more time correcting them, negating the benefits of speculative decoding. Ensuring this alignment typically involves fine-tuning or distillation techniques that transfer knowledge from the target model to the draft model. Another critical aspect of speculative decoding is the confidence threshold used by the target model to accept or reject the draft model's tokens. If the threshold is too strict, the target model rejects too many tokens, increasing its workload and reducing efficiency. Conversely, if the threshold is too lenient, the system may accept suboptimal tokens, degrading output quality. Fine-tuning this parameter requires careful experimentation and may vary depending on the application. Speculative decoding can also integrate with parallel computation to further enhance efficiency. For example, while the target model processes one batch of tokens, the draft model can begin generating the next batch. This overlap reduces idle time for both models and maximizes throughput, making speculative decoding scalable for high-volume systems. While challenges like draft-target alignment and confidence threshold tuning exist, ongoing advancements in model training and inference techniques promise to make speculative decoding even more robust and accessible. This technique is poised to play a pivotal role in the future of AI deployment, particularly as demand for high-speed, high-quality systems continues to grow. The code above is publicly available in my github https://github.com/philhopkinsML Speculative decoding is an advanced AI inference technique that is gaining traction in natural language processing (NLP) and other sequence generation tasks. It addresses one of the most significant challenges in deploying large-scale models: balancing computational efficiency with the quality of generated outputs. Models like GPT-3 and GPT-4 have set new benchmarks in AI capability but are computationally expensive, especially for real-time applications such as chatbots, translation systems, and interactive assistants. Speculative decoding offers a clever solution by introducing a two-model system: a smaller, faster draft model and a larger, more accurate target model. This approach reduces latency without compromising the quality of the generated sequences. At its core, speculative decoding is a two-step process. First, a lightweight draft model generates a sequence of tokens quickly. This model is typically a distilled version of the target model or another smaller model trained for speed. The draft model's output is not final but serves as a proposal. The second step involves the larger, more accurate target model, which evaluates the draft model’s tokens. The target model either accepts the proposed tokens if they meet a confidence threshold or refines them if they do not. This process allows the system to leverage the efficiency of the draft model while maintaining the precision of the target model. The reason speculative decoding is particularly appealing lies in its ability to reduce the computational burden of the larger model. By delegating the initial token generation to the draft model, the target model operates selectively, focusing only on validation or correction rather than generating every token from scratch. This division of labor significantly reduces inference latency and resource consumption, making it a preferred technique for real-time applications. The technique works well in scenarios where speed is critical, and the quality of generated outputs cannot be compromised. For instance, in chat-based applications, users expect near-instantaneous responses. Speculative decoding ensures that the system generates text quickly while retaining the nuanced understanding of the larger model. Similarly, in real-time translation systems, where delays can disrupt communication, speculative decoding provides a practical way to meet latency constraints. To understand speculative decoding more concretely, let us consider a code implementation. Below is an example that demonstrates how speculative decoding could be implemented using PyTorch and Hugging Face's Transformers library. This implementation involves a draft model (a smaller, faster version like DistilGPT-2) and a target model (a larger, more accurate model like GPT-2). from transformers import AutoModelForCausalLM, AutoTokenizer

# Load the draft (smaller) and target (larger) models

draft_model_name = "distilgpt2"  # Smaller, faster model 

target_model_name = "gpt2"      # Larger, more accurate model

draft_tokenizer = AutoTokenizer.from_pretrained(draft_model_name) draft_model = AutoModelForCausalLM.from_pretrained(draft_model_name)

target_tokenizer = AutoTokenizer.from_pretrained(target_model_name) target_model = AutoModelForCausalLM.from_pretrained(target_model_name)

def speculative_decode(prompt, max_length=50, threshold=0.9): """ Performs speculative decoding using a draft model and a target model.

Args:
    prompt (str): The input text to the model.
    max_length (int): The maximum length of the generated sequence.
    threshold (float): The confidence threshold for the target model to accept tokens.

Returns:
    str: The generated text sequence.
"""
# Step 1: Generate tokens using the draft model
draft_inputs = draft_tokenizer(prompt, return_tensors="pt")  # Tokenize the prompt
draft_outputs = draft_model.generate(draft_inputs.input_ids, max_length=max_length)  # Generate draft tokens
draft_tokens = draft_tokenizer.decode(draft_outputs[0], skip_special_tokens=True)  # Decode draft tokens to text

# Step 2: Verify tokens using the target model
target_inputs = target_tokenizer(draft_tokens, return_tensors="pt")  # Tokenize the draft output for the target model
target_logits = target_model(**target_inputs).logits  # Get logits (un-normalized probabilities) from the target model

# Step 3: Calculate confidence scores for each token
probs = target_logits.softmax(dim=-1)  # Convert logits to probabilities
confidence = probs.max(dim=-1).values.mean().item()  # Calculate the average confidence score across all tokens

# Step 4: Decide whether to accept or refine tokens
if confidence >= threshold:  # If confidence exceeds the threshold
    return draft_tokens  # Accept the draft tokens
else:  # Otherwise, refine the sequence using the target model
    refined_outputs = target_model.generate(target_inputs.input_ids, max_length=max_length)
    return target_tokenizer.decode(refined_outputs[0], skip_special_tokens=True)  # Return the refined sequence


prompt = "The future of AI is" output = speculative_decode(prompt, max_length=20) print(output) from transformers import AutoModelForCausalLM, AutoTokenizer

# Load the draft (smaller) and target (larger) models

draft_model_name = "distilgpt2"  # Smaller, faster model 

target_model_name = "gpt2"      # Larger, more accurate model

draft_tokenizer = AutoTokenizer.from_pretrained(draft_model_name) draft_model = AutoModelForCausalLM.from_pretrained(draft_model_name)

target_tokenizer = AutoTokenizer.from_pretrained(target_model_name) target_model = AutoModelForCausalLM.from_pretrained(target_model_name)

def speculative_decode(prompt, max_length=50, threshold=0.9): """ Performs speculative decoding using a draft model and a target model.

Args:
    prompt (str): The input text to the model.
    max_length (int): The maximum length of the generated sequence.
    threshold (float): The confidence threshold for the target model to accept tokens.

Returns:
    str: The generated text sequence.
"""
# Step 1: Generate tokens using the draft model
draft_inputs = draft_tokenizer(prompt, return_tensors="pt")  # Tokenize the prompt
draft_outputs = draft_model.generate(draft_inputs.input_ids, max_length=max_length)  # Generate draft tokens
draft_tokens = draft_tokenizer.decode(draft_outputs[0], skip_special_tokens=True)  # Decode draft tokens to text

# Step 2: Verify tokens using the target model
target_inputs = target_tokenizer(draft_tokens, return_tensors="pt")  # Tokenize the draft output for the target model
target_logits = target_model(**target_inputs).logits  # Get logits (un-normalized probabilities) from the target model

# Step 3: Calculate confidence scores for each token
probs = target_logits.softmax(dim=-1)  # Convert logits to probabilities
confidence = probs.max(dim=-1).values.mean().item()  # Calculate the average confidence score across all tokens

# Step 4: Decide whether to accept or refine tokens
if confidence >= threshold:  # If confidence exceeds the threshold
    return draft_tokens  # Accept the draft tokens
else:  # Otherwise, refine the sequence using the target model
    refined_outputs = target_model.generate(target_inputs.input_ids, max_length=max_length)
    return target_tokenizer.decode(refined_outputs[0], skip_special_tokens=True)  # Return the refined sequence


prompt = "The future of AI is" output = speculative_decode(prompt, max_length=20) print(output) In this implementation, the speculative decoding process begins with the draft model generating a sequence of tokens. These tokens are then passed to the target model, which calculates the confidence for each token. If the average confidence exceeds a pre-defined threshold, the tokens are accepted as is. Otherwise, the target model refines the sequence to ensure output quality. This code includes detailed comments explaining each step, from tokenizing the input for the draft model to generating and validating tokens with the target model. The threshold parameter can be adjusted based on the application’s tolerance for speed versus accuracy trade-offs. One of the primary challenges in implementing speculative decoding is training the draft model. The draft model must align closely with the target model in terms of predictions, as significant discrepancies can reduce the efficiency of the process. For example, if the draft model frequently proposes incorrect tokens, the target model spends more time correcting them, negating the benefits of speculative decoding. Ensuring this alignment typically involves fine-tuning or distillation techniques that transfer knowledge from the target model to the draft model. Another critical aspect of speculative decoding is the confidence threshold used by the target model to accept or reject the draft model's tokens. If the threshold is too strict, the target model rejects too many tokens, increasing its workload and reducing efficiency. Conversely, if the threshold is too lenient, the system may accept suboptimal tokens, degrading output quality. Fine-tuning this parameter requires careful experimentation and may vary depending on the application. Speculative decoding can also integrate with parallel computation to further enhance efficiency. For example, while the target model processes one batch of tokens, the draft model can begin generating the next batch. This overlap reduces idle time for both models and maximizes throughput, making speculative decoding scalable for high-volume systems. While challenges like draft-target alignment and confidence threshold tuning exist, ongoing advancements in model training and inference techniques promise to make speculative decoding even more robust and accessible. This technique is poised to play a pivotal role in the future of AI deployment, particularly as demand for high-speed, high-quality systems continues to grow. The code above is publicly available in my github https://github.com/philhopkinsML https://github.com/philhopkinsML

Meet The AI Tag-Team Method That Reduces Latency in Your Model's Response

Smarter Systems, Less Hassle: Inside DBMS Auto-Tuning

Authors:
(1) Limeng Zhang, Centre for Research on Engineering Software Technologies (CREST), The University of Adelaide, Australia;
(2) M. Ali Babar, Centre for Research on Engineering Software Technologies (CREST), The University of Adelaide, Australia. Table of Links Abstract and 1 Introduction 1.1 Configuration Parameter Tuning Challenges and 1.2 Contributions 2 Tuning Objectives 3 Overview of Tuning Framework 4 Workload Characterization and 4.1 Query-level Characterization 4.2 Runtime-based Characterization 5 Feature Pruning and 5.1 Workload-level Pruning 5.2 Configuration-level Pruning 5.3 Summary 6 Knowledge from Experience 7 Configuration Recommendation and 7.1 Bayesian Optimization 7.2 Neural Network 7.3 Reinforcement Learning 7.4 Search-based Solutions 8 Experimental Setting 9 Related Work 10 Discussion and Conclusion, and References 7.4 Search-based Solutions Search-based methods iteratively search for optimal configuration parameters by evaluating the system’s performance under different configurations. The core of search-based methods is to design the search strategy to handle the tradeoff between exploration(searching broadly across the configuration space to discover new and potentially promising regions) and exploitation (intensively searching in regions believed to be promising based on the available information). BestConfig [10] recommends configuration parameters through an iterative process consisting of the divide & diverge sampling for sample collection and the recursive bound & search for configuration parameter recommendation. Specifically, it first discretizes the parameter ranges for each parameter into several intervals (divide), and then selects a set of samples by considering each interval of a parameter once (diverge). In the recursive bound & search phase, it starts by searching the point with the best performance among the selected samples. Then, it searches from its surrounding points for better performance (bound). If such point are found, it conducts sampling around the new sample. This optimization process is iteratively conducted until no point with better performance is found. AutoTune [11] is an automatic parameter tuning system that aims to optimize application execution time on big data analytics frameworks. It executes experiments on both the production cluster and on a smaller-scale testbed to perform more test runs. It consists of three main steps. First, AutoTune executes the application using different data sizes and numbers of machines to build a parametric model. The model is used to select the data and cluster size for running the experiments within a time budget. The second step involves (i) exploration via using latin hypercube sampling (LHS) for generating different configurations to execute and (ii) exploitation via building and employing a Random Forest model for finding promising configurations to execute. In the final step, the best q configurations are used for executing the application on the production and determining the best one. UDAO [20] considers the tuning problem as a principled multi-objective optimization (MOO) approach that takes multiple, possibly conflicting, objectives, computes a Pareto optimal set of configurations (i.e., not dominated by any other configuration in all objectives), and returns one from the set that best suits the objectives. To be specific, it incrementally transforming a MOO problem to a set of constrained optimization (CO) problems, where each CO problem can be solved individually to return a Pareto optimal point. This paper is available on arxiv under CC BY 4.0 DEED. Authors: (1) Limeng Zhang, Centre for Research on Engineering Software Technologies (CREST), The University of Adelaide, Australia; (2) M. Ali Babar, Centre for Research on Engineering Software Technologies (CREST), The University of Adelaide, Australia. Authors: Authors: (1) Limeng Zhang, Centre for Research on Engineering Software Technologies (CREST), The University of Adelaide, Australia; (2) M. Ali Babar, Centre for Research on Engineering Software Technologies (CREST), The University of Adelaide, Australia. Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 1.1 Configuration Parameter Tuning Challenges and 1.2 Contributions 1.1 Configuration Parameter Tuning Challenges and 1.2 Contributions 2 Tuning Objectives 2 Tuning Objectives 3 Overview of Tuning Framework 3 Overview of Tuning Framework 4 Workload Characterization and 4.1 Query-level Characterization 4 Workload Characterization and 4.1 Query-level Characterization 4.2 Runtime-based Characterization 4.2 Runtime-based Characterization 5 Feature Pruning and 5.1 Workload-level Pruning 5 Feature Pruning and 5.1 Workload-level Pruning 5.2 Configuration-level Pruning 5.2 Configuration-level Pruning 5.3 Summary 5.3 Summary 6 Knowledge from Experience 6 Knowledge from Experience 7 Configuration Recommendation and 7.1 Bayesian Optimization 7 Configuration Recommendation and 7.1 Bayesian Optimization 7.2 Neural Network 7.2 Neural Network 7.3 Reinforcement Learning 7.3 Reinforcement Learning 7.4 Search-based Solutions 7.4 Search-based Solutions 8 Experimental Setting 8 Experimental Setting 9 Related Work 9 Related Work 10 Discussion and Conclusion, and References 10 Discussion and Conclusion, and References 7.4 Search-based Solutions Search-based methods iteratively search for optimal configuration parameters by evaluating the system’s performance under different configurations. The core of search-based methods is to design the search strategy to handle the tradeoff between exploration(searching broadly across the configuration space to discover new and potentially promising regions) and exploitation (intensively searching in regions believed to be promising based on the available information). BestConfig [10] recommends configuration parameters through an iterative process consisting of the divide & diverge sampling for sample collection and the recursive bound & search for configuration parameter recommendation. Specifically, it first discretizes the parameter ranges for each parameter into several intervals (divide), and then selects a set of samples by considering each interval of a parameter once (diverge). In the recursive bound & search phase, it starts by searching the point with the best performance among the selected samples. Then, it searches from its surrounding points for better performance (bound). If such point are found, it conducts sampling around the new sample. This optimization process is iteratively conducted until no point with better performance is found. AutoTune [11] is an automatic parameter tuning system that aims to optimize application execution time on big data analytics frameworks. It executes experiments on both the production cluster and on a smaller-scale testbed to perform more test runs. It consists of three main steps. First, AutoTune executes the application using different data sizes and numbers of machines to build a parametric model. The model is used to select the data and cluster size for running the experiments within a time budget. The second step involves (i) exploration via using latin hypercube sampling (LHS) for generating different configurations to execute and (ii) exploitation via building and employing a Random Forest model for finding promising configurations to execute. In the final step, the best q configurations are used for executing the application on the production and determining the best one. UDAO [20] considers the tuning problem as a principled multi-objective optimization (MOO) approach that takes multiple, possibly conflicting, objectives, computes a Pareto optimal set of configurations (i.e., not dominated by any other configuration in all objectives), and returns one from the set that best suits the objectives. To be specific, it incrementally transforming a MOO problem to a set of constrained optimization (CO) problems, where each CO problem can be solved individually to return a Pareto optimal point. This paper is available on arxiv under CC BY 4.0 DEED. This paper is available on arxiv under CC BY 4.0 DEED. available on arxiv

Stories, News & Mentions about AUTOZONE

Autozone’s Stories on HackerNoon

Autozone's News & Mentions