AI holds promise for India's case backlog, but overcoming legal complexities, privacy concerns, and biases is crucial for successful implementation in courts.

AI’s Promising Role in Tackling India’s Judicial Backlog

Investors can make smarter financial decisions when they recognize pitfalls and engage in strategic ways to avoid them.

How investors can make smarter financial decisions

Local Dallas doctors talk about the pros and cons around Ozempic, the popular drug intended for diabetes patients but finding its fame linked to weight loss.

Ozempic — is it really the miracle drug that it seems to be?

21 Weight Loss Tips You Should Definitely Ignore, And What To Do Instead

The NIH has been struggling for years to make its grant review process fair and to ensure that peer review panels choose the best research proposals. The new framework also shifts some of the administrative burden from peer reviewers to NIH staff to allow reviewers to focus more on the science.

NIH revamps grant review process to reduce bias

A recent study in JAMA Psychiatry used Mendelian Randomization to examine the link between low birth weight and neurodevelopmental issues in children. The research found no causal relationship between maternal genetic factors affecting birth weight and offspring neurodevelopment,

Study challenges link between low birth weight and childhood neurodevelopmental issues

The cost of weight bias is also astronomical for patients, with effects going beyond those based on the physical effects of obesity alone. Credit: Getty Images. People who are overweight and obese face many forms of bias, such as weight-based stereotypes ...

Recognizing and Countering Weight Bias in Medicine

It is a dynamic interplay where one's mental state can impact physical health and vice versa. A recent study, "Developmental Trajectory of Body Weight in Youths at Risk for Major Mood Disorders," published in JAMA Network Open, examines the complex ...

Depression in Parents May Influence Children's Weight

Survey of youth athletes pinpoints causes of sports attrition ORLANDO, Fla., Oct. 20, 2023 /PRNewswire/ -- Body image issues, social media,

Body Image, Social Media and Gender Biases Associated with Kids Quitting Sports

Survey of youth athletes pinpoints causes of sports attrition. ORLANDO, Fla., Oct. 20, 2023 /PRNewswire/ -- Body image issues, social media, gender biases and coaching styles may

Weights & Biases

weights-biases

Hey HackerNoon Fam, In honor of spooky season, we want to share tricks & tips (see what we did there? No? pfft) for writing scary good stories on HackerNoon! Our focus today is on Listicles. Let’s get right to it! Start Writing Your Listicle Today! How to Write Winning Listicles on HackerNoon In a world where we’re harassed by impossible choices at every turn, listicles are an invaluable resource that narrows our options and makes choosing easier. Unfortunately, today, the internet is filled with low-quality, spammy, promotional listicles. They all say these are the “best”, without any objective proof. We don’t want spammy listicles at HackerNoon. So, here are 6 steps to write a winning listicle: Identify your subject matter. Start by pinpointing the specific topic or subject you want to cover with your listicle. This will serve as the central theme around which you'll build your list. Research. Research. Research. Invest time and effort in thorough research to gather comprehensive information about your chosen subject. Your listicle's credibility depends on the quality of your research. Based on your research, clearly define your Selection criteria. The key to a valuable listicle is clearly defining "why" your chosen items are featured. For instance, in a list like "Top 10 travel destinations," explain your selection criteria—such as trip cost, safety, accommodation quality, and more. This ensures transparency and credibility. Decide whether you’re working on a ranked or unranked listicle. Determine if you'll be ranking the items in your list (e.g., "Top 10") or presenting them without a specific order (e.g., "15 Must-Try Recipes"). Based on your research & selection criteria, decide the order of your listicle i.e. ascending or descending. If you're creating a ranked listicle, decide whether the items will be presented in ascending order (e.g., from 10 to 1) or descending order (e.g., from 1 to 10). Your choice should align with your selection criteria. Start writing your listicle! Make sure to maintain a consistent format, tone, and style. Got it? Write your next listicle here. For more context, here are some really good listicles on HackerNoon: 1. Top 15 AI Companies Hiring in 2023 - by Salary Range The title of the article immediately reveals the specific ranking criterion used, which in this case is the "Salary Range." The author has meticulously curated a well-researched list featuring 15 AI companies actively hiring at the time of publication. These companies are thoughtfully arranged in descending order, starting with the highest salary range at OpenAI and concluding with the lowest salary range at Weights & Biases. https://hackernoon.com/top-15-ai-companies-hiring-in-2023-by-salary-range?embedable=true The Tom Holland Spider-Man Movies in Order of Release Date This is self-explanatory. The author of this article has ordered all of Tom Holland’s Spiderman movies in order of their release dates. Side note: This is one of the best-performing articles on HackerNoon. S/O listicles! https://hackernoon.com/the-tom-holland-spider-man-movies-in-order-of-release-date?embedable=true Top 10 Machine Learning Optimized Graphics Cards In this article, the author ranks the top 10 Machine Learning Optimized Graphic Cards based on meticulously researched ranking criteria including computing power, GPU memory, support & compatibility with machine learning frameworks. https://hackernoon.com/top-10-machine-learning-optimized-graphics-cards?embedable=true Ready to get cracking? Write your Winning Listicle here. HackerNoon Mobile App Review Contest Extended for a Month Last month, to celebrate the dedicated community that made the HackerNoon Mobile App launch possible, we announced a review contest where users stand a chance to win $1000. If you haven’t heard or gotten a chance to share your review, don’t worry, we’ve decided to keep the contest open for an extra month! Follow these steps and win big! Good luck! Take Full Advantage of Your HackerNoon Profile Page Did you know that you can add brand or personal ads as massive CTAs on your profile page, just like in the image below? No? Well, it’s really easy. Here’s all you need to do: Click on the edit button, right above your display name, on your profile page.
This will direct you to the page below where you can update your Call to Action Text & Call to Action Link. Voila! That’s all from us for today. For more writing tips visit the HackerNoon Editing Protocol. Have a great day! Hey HackerNoon Fam, In honor of spooky season, we want to share tricks & tips (see what we did there? No? pfft) for writing scary good stories on HackerNoon! scary good stories Our focus today is on Listicles . Listicles Let’s get right to it! Start Writing Your Listicle Today! Start Writing Your Listicle Today! Start Writing Your Listicle Today! How to Write Winning Listicles on HackerNoon How to Write Winning Listicles on HackerNoon In a world where we’re harassed by impossible choices at every turn, listicles are an invaluable resource that narrows our options and makes choosing easier. Unfortunately, today, the internet is filled with low-quality, spammy, promotional listicles. They all say these are the “best”, without any objective proof. We don’t want spammy listicles at HackerNoon. So, here are 6 steps to write a winning listicle: Identify your subject matter. Identify your subject matter. Identify your subject matter. Start by pinpointing the specific topic or subject you want to cover with your listicle. This will serve as the central theme around which you'll build your list. Research. Research. Research. Research. Research. Research. Research. Research. Research. Invest time and effort in thorough research to gather comprehensive information about your chosen subject. Your listicle's credibility depends on the quality of your research. Based on your research, clearly define your Selection criteria. Based on your research, clearly define your Selection criteria. Based on your research, clearly define your Selection criteria. The key to a valuable listicle is clearly defining "why" your chosen items are featured. For instance, in a list like "Top 10 travel destinations," explain your selection criteria—such as trip cost, safety, accommodation quality, and more. This ensures transparency and credibility. Decide whether you’re working on a ranked or unranked listicle. Decide whether you’re working on a ranked or unranked listicle. Decide whether you’re working on a ranked or unranked listicle. Determine if you'll be ranking the items in your list (e.g., "Top 10") or presenting them without a specific order (e.g., "15 Must-Try Recipes"). Based on your research & selection criteria, decide the order of your listicle i.e. ascending or descending. Based on your research & selection criteria, decide the order of your listicle i.e. ascending or descending. Based on your research & selection criteria, decide the order of your listicle i.e. ascending or descending. If you're creating a ranked listicle, decide whether the items will be presented in ascending order (e.g., from 10 to 1) or descending order (e.g., from 1 to 10). Your choice should align with your selection criteria. Start writing your listicle! Start writing your listicle! Start writing your listicle! Make sure to maintain a consistent format, tone, and style. Got it? Write your next listicle here. Got it? Write your next listicle here. Write your next listicle here. Write your next listicle here. For more context, here are some really good listicles on HackerNoon: For more context, here are some really good listicles on HackerNoon: 1. Top 15 AI Companies Hiring in 2023 - by Salary Range 1. Top 15 AI Companies Hiring in 2023 - by Salary Range Top 15 AI Companies Hiring in 2023 - by Salary Range The title of the article immediately reveals the specific ranking criterion used, which in this case is the "Salary Range." The author has meticulously curated a well-researched list featuring 15 AI companies actively hiring at the time of publication. These companies are thoughtfully arranged in descending order, starting with the highest salary range at OpenAI and concluding with the lowest salary range at Weights & Biases. https://hackernoon.com/top-15-ai-companies-hiring-in-2023-by-salary-range?embedable=true https://hackernoon.com/top-15-ai-companies-hiring-in-2023-by-salary-range?embedable=true The Tom Holland Spider-Man Movies in Order of Release Date The Tom Holland Spider-Man Movies in Order of Release Date The Tom Holland Spider-Man Movies in Order of Release Date The Tom Holland Spider-Man Movies in Order of Release Date This is self-explanatory. The author of this article has ordered all of Tom Holland’s Spiderman movies in order of their release dates. Side note: This is one of the best-performing articles on HackerNoon. S/O listicles! https://hackernoon.com/the-tom-holland-spider-man-movies-in-order-of-release-date?embedable=true https://hackernoon.com/the-tom-holland-spider-man-movies-in-order-of-release-date?embedable=true Top 10 Machine Learning Optimized Graphics Cards Top 10 Machine Learning Optimized Graphics Cards Top 10 Machine Learning Optimized Graphics Cards Top 10 Machine Learning Optimized Graphics Cards In this article, the author ranks the top 10 Machine Learning Optimized Graphic Cards based on meticulously researched ranking criteria including computing power, GPU memory, support & compatibility with machine learning frameworks. https://hackernoon.com/top-10-machine-learning-optimized-graphics-cards?embedable=true https://hackernoon.com/top-10-machine-learning-optimized-graphics-cards?embedable=true Ready to get cracking? Write your Winning Listicle here. Ready to get cracking? Write your Winning Listicle here. Write your Winning Listicle here. Write your Winning Listicle here. HackerNoon Mobile App Review Contest Extended for a Month HackerNoon Mobile App Review Contest Extended for a Month Last month, to celebrate the dedicated community that made the HackerNoon Mobile App launch possible, we announced a review contest where users stand a chance to win $1000 . If you haven’t heard or gotten a chance to share your review, don’t worry, we’ve decided to keep the contest open for an extra month! Follow these steps and win big! Good luck! HackerNoon Mobile App announced a review contest $1000 Follow these steps Take Full Advantage of Your HackerNoon Profile Page Take Full Advantage of Your HackerNoon Profile Page Did you know that you can add brand or personal ads as massive CTAs on your profile page, just like in the image below? massive CTAs No? Well, it’s really easy. Here’s all you need to do: Here’s all you need to do: Click on the edit button, right above your display name, on your profile page. This will direct you to the page below where you can update your Call to Action Text & Call to Action Link. Click on the edit button, right above your display name, on your profile page. This will direct you to the page below where you can update your Call to Action Text & Call to Action Link . Call to Action Text & Call to Action Link Voila! Voila! That’s all from us for today. For more writing tips visit the HackerNoon Editing Protocol. HackerNoon Editing Protocol. Have a great day!

Scary-good Writing Tips: Learn How to Write a Listicle

The Prime Minister of Israel, Benjamin Netanyahu asks; "What are we going to do when people don't have jobs and shell out money for them?" Elon musk: “What's bad in living in paradise? It's the concept of heaven..." The Disparity Between Silicon Valley and Washington As Bill Murley aptly notes, the gap between San Francisco and Washington is a staggering 2,851 miles—more than just geographical distance, it symbolizes the disconnect between the tech world and political realities. As an effective accelerationist (e/acc), I argue that we should focus on expediting technological advancement rather than getting bogged down in regulatory quagmires. There are immediate problems that AI could be tackling, but instead, we're stuck in this back-and-forth about regulations and safety protocols. However, if you've interacted with AI agents like , , or even platforms like Replicate, HuggingFace, and Weights & Biases, you know that the concept of the singularity doesn't seem so far off. BabyAGI CamelAI SuperAGI If you're focused on understanding AI's long-term impact and implications, this is a conversation you can't afford to overlook. The Dual Facets of AI: A Catalyst and a Cautionary Tale Greg Brockman and Max Tegmark touch on our shared responsibility. AI stands as a transformative force but also as an existential challenge that demands a focus on safety protocols. The free market fuels this rapid innovation, but the panelists caution against passive acceptance of potential monopolies in the AI domain. The risk? Nothing less than human extinction. AI and Society: Reimagining Work and Wealth As AI evolves, the very fabric of our work lives is at stake. While technological advancements could free human time, they could also deepen social divides. This dichotomy ushers in the idea of frameworks like as a countermeasure. Universal Basic Income The Prospective Utopia and Our Place in It The future, if steered rightly, promises an AI-enabled utopia—an endless horizon of material abundance and enhanced human experiences. Yet, this is not a guarantee but a potential outcome hinging on today’s choices. Merging Futures: The Convergence of Human and Artificial Minds Inspired by Ray Kurzweil's "The Singularity is Near," Netanyahu champions the notion of a future where human and AI capabilities merge into a symbiotic relationship. Elon Musk takes this a step further by introducing Neuralink as not just a tool for human enhancement but as a safety buffer in a world inching closer to AGI. Navigating the Regulatory Maze Before the curtain falls, the conversation tilts towards the inevitable: regulation. The panel concurs that a global safety framework is imperative, much like the one in the biotech sector. This aligns with proactive steps already underway in countries like China. The Choice is Ours: Accelerate Responsibly The narrative that unfolds from this roundtable serves as an e/acc roadmap, outlining how we can and should expedite AI and AGI for societal betterment. The takeaway? The future is not predetermined but crafted by our choices today. If you’re tuned into the AI dialogue, this discussion isn’t just recommended—it’s required. Engage, share, and most importantly, act. You can watch more here: https://twitter.com/i/status/1705676466946482571?embedable=true

AGI 2029: Walking the Fine Line Between Utopia and Existential Risks

open sourcing in February marked a significant step for those looking for accessible yet potent libraries. Rerun's Python visualization Why is visualization important? Visualization is essential since companies like Scale.ai, Weights & Biases, and Hugging Face have streamlined deep learning by addressing dataset labeling, experiment tracking, and pre-trained models. However, a void still exists in rapid data capture and visualization. Many companies develop in-house data visualization solutions but often end up with suboptimal tools due to high development costs. Moreover, Python visualization on data is a problem that is not solved well either, leading to t-based solutions in notebooks. Rerun leverages a Python interface into a high-performant visualization engine (much like Bytewax!) that makes it dead easy to analyze streaming data. streaming JavaScrip Rust In this blog post, we will explore how to use Bytewax and Rerun to visualize real-time streaming data in Python and create a real-time anomaly detection visualization. We chose anomaly detection, a.k.a. outlier detection because it is a critical component in numerous applications, such as cybersecurity, fraud detection, and monitoring of industrial processes. Visualizing these anomalies in real-time can aid in quickly identifying potential issues and taking necessary actions to mitigate them. For those eager to dive in, check out our end-to-end Python solution on our . Don't forget to star Bytewax! GitHub Overview Here is what we'll cover: We will navigate the code and briefly discuss top-level entities Then we will discuss each step of the dataflow in greater detail: initialization of our dataflow, input source, stateful anomaly detection, data visualization & output, and how to spawn a cluster Finally, we will learn how to run it and see the beautiful visualization, all in Python <3 As a bonus, we will think about other use cases Let's go! Setup your environment This blog post is based on the following versions of Bytewax and Rerun: bytewax==0.15.1
rerun-sdk==0.4.0 Rerun and Bytewax are installable as pip install rerun-sdk
pip install bytewax Follow Bytewax for updates as we are baking a new version that will ease the development of data streaming apps in Python further. Code The solution is relatively compact, so we copy the entire code example here. Please feel free to skip this big chunk if it looks overwhelming; we will discuss each function later. import random
# pip install rerun-sdk
import rerun as rr

from time import sleep
from datetime import datetime

from bytewax.dataflow import Dataflow
from bytewax.execution import spawn_cluster
from bytewax.inputs import ManualInputConfig, distribute
from bytewax.outputs import ManualOutputConfig


rr.init("metrics")
rr.spawn()

start = datetime.now()

def generate_random_metrics(worker_index, worker_count, resume_state):
    assert resume_state is None
    keys = ["1", "2", "3", "4", "5", "6"]
    this_workers_keys = distribute(keys, worker_index, worker_count)

    for _ in range(1000):
        for key in this_workers_keys:
            value = random.randrange(0, 10)
            if random.random() > 0.9:
                value *= 2.0
            yield None, (key, (key, value, (datetime.now() - start).total_seconds()))
            sleep(random.random() / 10.0)


class ZTestDetector:
    """Anomaly detector.

    Use with a call to flow.stateful_map().

    Looks at how many standard deviations the current item is away
    from the mean (Z-score) of the last 10 items. Mark as anomalous if
    over the threshold specified.
    """

    def __init__(self, threshold_z):
        self.threshold_z = threshold_z

        self.last_10 = []
        self.mu = None
        self.sigma = None

    def _push(self, value):
        self.last_10.insert(0, value)
        del self.last_10[10:]

    def _recalc_stats(self):
        last_len = len(self.last_10)
        self.mu = sum(self.last_10) / last_len
        sigma_sq = sum((value - self.mu) ** 2 for value in self.last_10) / last_len
        self.sigma = sigma_sq**0.5

    def push(self, key__value__t):
        key, value, t = key__value__t
        is_anomalous = False
        if self.mu and self.sigma:
            is_anomalous = abs(value - self.mu) / self.sigma > self.threshold_z

        self._push(value)
        self._recalc_stats()
        rr.log_scalar(f"temp_{key}/data", value, color=[155, 155, 155])
        if is_anomalous:
            rr.log_point(f"3dpoint/anomaly/{key}", [t, value, float(key) * 10], radius=0.3, color=[255,100,100])
            rr.log_scalar(
                f"temp_{key}/data/anomaly",
                value,
                scattered=True,
                radius=3.0,
                color=[255, 100, 100],
            )
        else:
            rr.log_point(f"3dpoint/data/{key}", [t, value, float(key) * 10], radius=0.1)

        return self, (value, self.mu, self.sigma, is_anomalous)


def output_builder(worker_index, worker_count):
    def inspector(input):
        metric, (value, mu, sigma, is_anomalous) = input
        print(
            f"{metric}: "
            f"value = {value}, "
            f"mu = {mu:.2f}, "
            f"sigma = {sigma:.2f}, "
            f"{is_anomalous}"
        )

    return inspector


if __name__ == '__main__':
    flow = Dataflow()
    flow.input("input", ManualInputConfig(generate_random_metrics))
    # ("metric", value)
    flow.stateful_map("AnomalyDetector", lambda: ZTestDetector(2.0), ZTestDetector.push)
    # ("metric", (value, mu, sigma, is_anomalous))
    flow.capture(ManualOutputConfig(output_builder))
    spawn_cluster(flow) The provided code demonstrates how to create a real-time anomaly detection pipeline using Bytewax and Rerun. Let's break down the essential components of this code: : This function generates random metrics simulating real-world data streams. It generates data points with a small chance of having an anomaly (values doubled). generate_random_metrics : This class implements an anomaly detector using the Z-score method. It maintains the mean and standard deviation of the last 10 values and marks a value as anomalous if its Z-score is greater than a specified threshold. ZTestDetector : This function is used to define the output behavior for the data pipeline. In this case, it prints the metric name, value, mean, standard deviation, and whether the value is anomalous. output_builder : The main part of the code constructs the dataflow using Bytewax, connecting the RandomMetricInput, ZTestDetector, and the output builder. Dataflow : The Rerun visualization is integrated into the ZTestDetector class. The rr.log_scalar and rr.log_point functions are used to plot the data points and their corresponding anomaly status. Rerun visualization Now, with an understanding of the code's main components, let's discuss how the visualization is created step by step. Building the Dataflow To create a dataflow pipeline, you need to: Initialize a new dataflow with . flow = Dataflow() Define the input source using . flow.input("input", ManualInputConfig(generate_random_metrics)) Apply the stateful anomaly detector using . flow.stateful_map("AnomalyDetector", lambda: ZTestDetector(2.0), ZTestDetector.push) Configure the output behavior with . flow.capture(ManualOutputConfig(output_builder)) Finally, spawn a cluster to execute the dataflow with . spawn_cluster(flow, proc_count=3) The resulting dataflow reads the randomly generated metric values from , passes them through the for anomaly detection, and outputs the results using the function. Let's clarify the details for each step. input_builder ZTestDetector output_builder function generate_random_metrics The function serves as an alternative input source for the dataflow pipeline, generating random metric values in a distributed manner across multiple workers. It accepts three parameters: , , and . generate_random_metrics worker_index worker_count resume_state def generate_random_metrics(worker_index, worker_count, resume_state):
    assert resume_state is None
    keys = ["1", "2", "3", "4", "5", "6"]
    this_workers_keys = distribute(keys, worker_index, worker_count)

    for _ in range(1000):
        for key in keys:
            value = random.randrange(0, 10)
            if random.random() > 0.9:
                value *= 2.0
            yield None, (key, (key, value, (datetime.now() - start).total_seconds()))
            sleep(random.random() / 10.0) : The index of the current worker in the dataflow pipeline. worker_index : The total number of workers in the dataflow pipeline. worker_count : The state of the input source from which to resume. In this case, it is asserted to be , indicating that the input source does not support resuming from a previous state. resume_state None Here's a step-by-step description of the generate_random_metrics function: Assert that is . resume_state None Define a list of keys representing the metrics. Distribute the keys among the workers using the distribute function (not provided in the code snippet). The distributed keys for the current worker are assigned to this_workers_keys. Iterate 1,000 times and, for each iteration, iterate through the list of keys: Generate a random value between 0 and 10. With a 10% probability, double the value to simulate an anomaly. Yield a tuple containing None (to indicate no specific partition key), the key, the generated value, and the elapsed time since the starting time (not provided in the code snippet). Introduce a sleep time between each generated value to simulate real-time data generation. The function is used in the dataflow as the input source with the following line of code: generate_random_metrics flow.input("input", ManualInputConfig(generate_random_metrics)) This line tells the dataflow to use the class to generate the input data for the pipeline. RandomMetricInput Class ZTestDetector The class is an anomaly detector that uses the Z-score method to identify whether a data point is anomalous or not. The Z-score is the number of standard deviations a data point is from the mean of a dataset. If a data point's Z-score is higher than a specified threshold, it is considered anomalous. ZTestDetector The class has the following methods: : The constructor initializes the ZTestDetector with a threshold Z-score value. It also initializes the last 10 values list (self.last_10), mean (self.mu), and standard deviation (self.sigma). __init__(self, threshold_z) : This private method is used to update the list of last 10 values with the new value. It inserts the new value at the beginning of the list and removes the oldest value, maintaining the list length at 10. _push(self, value) : This private method recalculates the mean and standard deviation based on the current values in the self.last_10 list. _recalc_stats(self) : This public method takes a tuple containing a key, a value, and a timestamp as input. It calculates the Z-score for the value, updates the last 10 values list, and recalculates the mean and standard deviation. It also logs the data point and its anomaly status using Rerun's visualization functions. Finally, it returns the updated instance of the ZTestDetector class and a tuple containing the value, mean, standard deviation, and anomaly status. push(self, key__value__t) The ZTestDetector class is used in the dataflow pipeline as a stateful map with the following code: flow.stateful_map("AnomalyDetector", lambda: ZTestDetector(2.0), ZTestDetector.push) This line tells the dataflow to apply the with a Z-score threshold of and use the method to process the data points. ZTestDetector 2.0 push Visualizing Anomalies To visualize the anomalies, the class logs the data points and their corresponding anomaly status using Rerun's visualization functions. Specifically, is used to plot a scalar value, while is used to plot 3D points. ZTestDetector rr.log_scalar rr.log_point The following code snippet shows how the visualization is created: rr.log_scalar(f"temp_{key}/data", value, color=[155, 155, 155])
if is_anomalous:
    rr.log_point(f"3dpoint/anomaly/{key}", [t, value, float(key) * 10], radius=0.3, color=[255,100,100])
    rr.log_scalar(
        f"temp_{key}/data/anomaly",
        value,
        scattered=True,
        radius=3.0,
        color=[255, 100, 100],
    )
else:
    rr.log_point(f"3dpoint/data/{key}", [t, value, float(key) * 10], radius=0.1) Here, we first log a scalar value representing the metric. Then, depending on whether the value is anomalous, we log a 3D point with a different radius and color. Anomalous points are logged in red with a larger radius, while non-anomalous points are logged with a smaller radius. Function output_builder The function is used to define the output behavior for the data pipeline. In this specific example, it is responsible for printing the metric name, value, mean, standard deviation, and whether the value is anomalous. output_builder The function takes two arguments: and . These arguments help the function understand the index of the worker and the total number of workers in the dataflow pipeline. worker_index worker_count Here's the definition of the output_builder function: def output_builder(worker_index, worker_count):
    def inspector(input):
        metric, (value, mu, sigma, is_anomalous) = input
        print(
            f"{metric}: "
            f"value = {value}, "
            f"mu = {mu:.2f}, "
            f"sigma = {sigma:.2f}, "
            f"{is_anomalous}"
        )

    return inspector This function is a higher-order function, which means it returns another function called . The function is responsible for processing the input data tuple and printing the desired output. inspector inspector The output builder function is later used in the dataflow pipeline when configuring the output behavior with flow.capture(ManualOutputConfig(output_builder)). Running the Dataflow Bytewax can run as a single process or in a multi-process way. This dataflow has been created to scale across multiple processes, but we will start off running it as a single process with the execution module. spawn_cluster spawn_cluster(flow) If we wanted to increase the parallelism, we would simply add more processes as arguments. For example - . spawn_cluster(flow, proc_count=3) To run the provided code we can simply run it as a Python script, but first we need to install the dependencies. Create a new file in the same directory as dataflow.py and name it requirements.txt. Add the following content to the requirements.txt file: bytewax==0.15.1
rerun-sdk==0.4.0 Open a terminal in the directory containing the requirements.txt and dataflow.py files. Install the dependencies using the following command: pip install -r requirements.txt And run the dataflow! python dataflow.py Expanding the Use Case While the provided code serves as a basic example of real-time anomaly detection, you can expand this pipeline to accommodate more complex scenarios. For example: : Replace the RandomMetricInput class with a custom class that reads data from a real-world source, such as IoT sensors, log files, or streaming APIs. Incorporate real-world data sources : You can replace the ZTestDetector class with other stateful anomaly detection methods, such as moving average, exponential smoothing, or machine learning-based approaches. Implement more sophisticated anomaly detection techniques : Enhance the Rerun visualization by adding more data dimensions, adjusting the color schemes, or modifying the plot styles to better suit your needs. Customize the Visualization : Instead of simply printing the anomaly results, you can integrate the pipeline with alerting or monitoring systems to notify the appropriate stakeholders when an anomaly is detected. Integrate with alerting and monitoring systems By customizing and extending the dataflow pipeline, you can create a powerful real-time anomaly detection and visualization solution tailored to your specific use case. The combination of Bytewax and Rerun offers a versatile and scalable foundation for building real-time data processing and visualization systems. Conclusion This blog post has demonstrated how to use Bytewax and Rerun to create a real-time anomaly detection visualization. By building a dataflow pipeline with Bytewax and integrating Rerun's powerful visualization capabilities, we can monitor and identify anomalies in our data as they occur. Originally written by Zander Matheson here. Join our community: Slack Github

Visualizing Real-Time Anomaly Detection with Python

Visualización de la detección de anomalías en tiempo real con Python

Visualiser la détection d'anomalies en temps réel avec Python

पायथन के साथ वास्तविक समय की विसंगति का पता लगाना

Python を使用したリアルタイムの異常検出の視覚化

Visualizando a detecção de anomalias em tempo real com Python

Trực quan hóa phát hiện bất thường theo thời gian thực bằng Python

使用 Python 可视化实时异常检测

Yet Another Lightning Hydra Template for ML Experiments

What is Hyperparameter Optimization? In machine learning, hyperparameter optimization or tuning is the problem of choosing a set of optimal hyperparameters for a learning algorithm. A hyperparameter is a parameter whose value is used to control the learning process. By contrast, the values of other parameters (typically node weights) are learned. Strategies Several strategies can be used for performing optimization. The most simple one is manual tuning. One such example is using the [Elbow Method](https://en.wikipedia.org/wiki/Elbow_method_(clustering) for determining the number of clusters in . On the other hand complex models, have dozens of hyperparameters, and combined with the fact that some of them are continuous, the size of the search space explodes, so the manual effort. To tackle this issue, several other "smarter" approaches exist. Some of them are: k -nearest neighbors algorithm Grid search Random search Bayesian optimization Gradient-based optimization Evolutionary optimization Population-based To get more familiar with how these approaches work and what are the differences between them, I encourage you to read these articles , , or . 7 Hyperparameter Optimization Techniques Every Data Scientist Should Know How To Make Deep Learning Models That Don’t Suck Hyperparameter Optimization Approaches Tooling Several frameworks provide implementations of the approaches mentioned above. In this tutorial, we are going to explore , . Weights & Biases - Sweeps (WANDB for short) Setup For this tutorial, we are going to build a classifier for the dataset. We will use from sklearn to predict the presence of heart disease. Heart Disease UCI RandomForestClassifier This tutorial does not focus on data pre-processing, so we'll dive straight into splitting the data into train and test data, and train the model once with default values for hyperparameters. import pandas as pd
from sklearn.model_selection import train_test_split

df = pd.read_csv('data\heart.csv')

X = df.drop(['target'], axis=1)
y = df['target']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2) Train the model rfc = RandomForestClassifier()
rfc.fit(X_train, y_train) and that's it, now we have successfully trained a random forest classifier with default values for its hyperparameters. This classifier has the following hyperparameters: bootstrap max_depth max_features min_samples_leaf min_samples_split n_estimators Now let's get into setting up the optimization: Optimization Step 1: Define the Training Script For more details, see the . docs This script should serve as the main entry point for optimization. It performs one training and evaluation of the model with values for the hyperparameters injected from outside (through ). wandb.config It gets the configuration from the outside and performs training and evaluation of the model with fixed values for all of the hyperparameters. The name could be arbitrary, and for this example is . train.py import wandb
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split

WANDB_PROJECT_NAME = "hyperparameter-optimization"

with wandb.init(project=WANDB_PROJECT_NAME):
    df = pd.read_csv('data\heart.csv')
    X = df.drop(['target'], axis=1)
    y = df['target']

    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

    config = wandb.config
    rfc = RandomForestClassifier(
        bootstrap=config.bootstrap,
        max_depth = config.max_depth,
        max_features = config.max_features,
        min_samples_leaf = config.min_samples_leaf,
        min_samples_split = config.min_samples_split,
        n_estimators = config.n_estimators,
    )

    rfc.fit(X_train, y_train)
    y_pred = rfc.predict(X_test)

    wandb.log({'accuracy': accuracy_score(y_test, y_pred)}) Step 2: Define the Optimization Strategy and Configuration To determine the optimization strategy, i.e. which approach to be used for optimization, what values or ranges should be tried for every hyper-parameter, and what objective to be optimized, a configuration file needs to be defined. sweep.yml This file contains some additional configuration regarding the python path, training script path (from Step 1), to get more familiar see the . docs For this example the file is. sweep.yml program: train.py
method: bayes
project: hyperparameter-optimization
command:
- ${env} 
- ~/envs/hyperopt/bin/python
- ${program}
- ${args}

metric:
  name: accuracy
  goal: maximize
parameters:
  bootstrap:
    values: [True, False]
  max_depth:
    values: [2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, None]
  max_features:
    values: ['auto', 'sqrt']
  min_samples_leaf:
    values: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  min_samples_split:
    values: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
  n_estimators:
    values: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 200, 300, 500] Interpretation is that the training script is located at , Bayesian optimization is going to be used and for bootstrap, the values and `False is going to be tried, for max_depth [2, 3, 4, .... ] and similarly for all of the hyperparameters. The objective is maximizing accuracy. So in other words, . train.py True we want to assign values to the hyperparameters such that the accuracy is maximized Step 3: Initializing and Running the optimization To start optimization, open a shell (with your favorite terminal emulator). Activate the python virtual environment (for UNIX , for other see the official Python .) source ~/envs/hyperopt/bin/python guide Initialize the sweep wandb sweep .\sweep.yml Expected Output: Run the sweep wandb agent aleksandar1932/hyperparameter-optimization/r3s5xf4d Expected Output: And that's it, now the running sweep can be observed at WANDB. Step 4: Monitoring Go to the sweep URL, from your shell output. For this example, the output is available , and below. here As the model is trained for different combinations for the hyperparameters, the results are updated in real-time. We can wait for the given approach to find the combination of values that when used for training, provide the best model, or stop the optimization either by terminating the running shell or through WANDB. Conclusion This sweep performed 79 runs, and the best model scored accuracy on a randomly sampled test set for that particular run. train_test_split is done for every run) 0.9016 (In train.py So, it can be concluded that the best RandomForestClassifier should be instantiated with the following hyperparameters. model = RandomForestClassifier(
        bootstrap=False,
        max_depth = 4,
        max_features = 'sqrt',
        min_samples_leaf = 3,
        min_samples_split = 4,
        n_estimators = 200,
    ) The code from this tutorial is available on . GitHub First published here

Using Weights and Biases to Perform Hyperparameter Optimization

In this post, we will try to build our own deep learning library in Python and begin to write a simple feedforward neural network. The focus will be on the . The content covering the training of our network will occur in the next post. forward pass Below you will find information on how feedforward neural networks take in input and produce an output from it. Firstly, What is a Neural Network? Neural networks are a machine learning technique that is loosely inspired by the model of the brain. As with all machine learning techniques, it learns from a dataset that contains inputs and their corresponding outputs. Neural networks consist of layers. Each layer is connected to the next layer with and . weights biases These weights and biases are used by the network to calculate the output it will give. They are adjusted when the network trains, so that the network produces the optimal output based on the data it trained on. This diagram shows a 3 layer neural network. The lines connecting the nodes are used to represent the weights and biases of the network. How do They Work? The MATH! Each layer has its own weights and bias. The weights and biases initially start as a matrix of random values. A basic feedforward neural network consists of only . linear layers Linear layers produce their output with the following formula: x @ w + b


Where...
x is the input to the layer
w is the weights of the layer
b is the bias of the layer
(@ means matrix multiply) The output of each layer is fed as an input into the next layer. Note If you are unaware of how matrix multiplication works, this website explains it nicely. here This is all we will cover for now - next post we will get into the mathematics behind how these weights and biases get corrected in training! Activation Functions Layers of neural nets are composed of nodes. Activation functions are applied to layers to determine which nodes should "fire"/"activate". This "firing" is observed in the human brain too, hence why it was introduced in neural networks since they are loosely based on the model of the brain. Activation functions also allow the network to model non-linear data. Without activation functions, the neural network would just be a linear regression model, meaning it would not be able to model most real-world data. There are multiple activation functions, but here are the most common ones used... Sigmoid The sigmoid function maps inputs to a value between 0 and 1, as shown in the graph below. (x is the input vector) Relu (Rectified Linear) The Relu function only allows positive values of the input vector to pass through. Negative values are mapped to 0. For example: [[-5, 10]  
 [15, -10] --> relu --> [[0, 10]
                         [15, 0]] Tanh Tanh is similar to Sigmoid, except it maps inputs to values between -1 and 1. Softmax Softmax takes in an input and maps it out as a probability distribution (meaning all the values in the output sum to 1). (z is the input vector, K is the length of the input vector) Writing the Code We will need NumPy for our matrix operations... import numpy as np First, let's write our linear layer class: class Linear:
    def __init__(self, units):
        #units specify how many nodes are in the layer
        self.units = units
        self.initialized = False

    def __call__(self, x):
        #initialize weights and biases if layer hasn't been called before
        if not self.initialized:
            self.w = np.random.randn(self.input.shape[-1], self.units)
            self.b = np.random.randn(self.units)
            self.initialized = True

        return self.input @ self.w + self.b Example usage... x = np.array([[0, 1]])
layer = Linear(5)
print (layer(x))

# => [[-2.63399933 -1.18289984  0.32129587  0.2903246  -0.2602642 ]] Now let's write all our activation function classes, following the formulae given previously: class Sigmoid:
    def __call__(self, x):
        return 1 / (1 + np.exp(-x))

class Relu:
    def __call__(self, x):
        return np.maximum(0, x)   

class Softmax:
    def __call__(self, x):
        return np.exp(x) / np.sum(np.exp(x))   

class Tanh:
    def __call__(self, x):
        return np.tanh(x) Now let's write a "Model" class, which will act as a container for all our layers / the actual neural network class. class Model:
    def __init__(self, layers):
        self.layers = layers
    
    def __call__(self, x):
        output = x
        for layer in self.layers:
            output = layer(x)
            
        return output Save all of those classes into " " (or any name you wish). layer.py Now we can build a simple neural network, with our tiny library so far: import layers
import numpy as np

#inputs array
x = np.array([[0, 1], [0, 0], [1, 1], [0, 1]])

#network uses all the layers we have designed so far
net = layers.Model([
    layers.Linear(32),
    layers.Sigmoid(),
    layers.Linear(16),
    layers.Softmax(),
    layers.Linear(8),
    layers.Tanh(),
    layers.Linear(4),
    layers.Relu(),
])

print (net(x)) Output:
[[0.         3.87770361 0.17602662 0.        ]
 [0.         3.85640582 0.22373699 0.        ]
 [0.         3.77290517 0.2469388  0.        ]
 [0.         3.87770361 0.17602662 0.        ]] Also published here.

How to Build Feedforward Neural Networks: A Step-by-Step Guide 

Hi! Let’s talk about versioning machine learning experiments and how it is different from tracking them. You may have heard of experiment tracking tools such as Weights&Biases, MLflow, or Neptune. They offer an API you can call from your code to log the experiment information which is then stored in a database, and you get access to a dashboard where you can visually compare your numerous experiments. This is a massive improvement over manually logging the machine learning experiments into a spreadsheet. However, if you want to a particular experiment, you still need to trace back your steps to stitch together the exact code, data, and pipeline to reproduce the experiment. Wouldn’t it be better to be able to automate this? We can actually do that if we move from tracking experiments to versioning them! This is something that we can do with a new feature that has been recently added to , an open-source tool mostly known in the context of Data Versioning. Let’s see how it works. reproduce or restore DVC Setup To experiments with DVC, initialize it from any Git repo with . Make sure your project is structured in the following way: start versioning dvc exp init -i This not only helps to organize the project in a logical way, but also helps DVC to version all the moving parts that make up an experiment. Next, instead of logging experiment metadata and metrics with a tracking tool, we’ll need to store them in files, so make sure that your training script reads the parameters from , and writes the resulting metrics into a . params.yaml metrics.json You may notice that when initializing DVC automatically creates a basic pipeline, and stores it in a file. With this setup your training code, pipeline, parameters, and metrics now live in files that can be versioned. dvc.yaml Once you set up your project like this, you can already point out a few benefits: Your training code has less dependencies and doesn’t need to call an external API to log experiment information. Your training code can use any programming language you like. Python, R, Julia, Java even? Pick your favorite! Your project is well organized. You can version control parameters, metrics, pipeline, code and data (DVC can handle large data that won’t fit in Git) The pipeline in captures everything needed to reproduce an experiment, and it can be versioned too. dvc.yaml In addition to these, there are some perks that may be less obvious at a first glance. Large Data and Model Versioning Large data and models aren’t easily tracked in Git, but with DVC you can keep them using your own storage, yet make them Git-compatible. When initialized DVC starts tracking the folder making Git ignore it yet storing and versioning it so you can back up versions anywhere and check them out alongside your experiment code. models Less noise when comparing experiments In a dashboard, you can see all of your experiments, and I mean ALL of them. It can be overwhelming to go through them even with filtering and sorting options. With version control you have more flexibility and control over what you share and how you organize things. You can keep your experiments in branches and choose not to push the ones with uninspiring results. That already reduces some of the clutter. But DVC can take it one step further. If you were to create a branch for each and every experiment, especially when doing hyperparameter tuning, this would result in way too many branches to fit any Git branching workflow. To help with that, DVC tracks your experiments so you don’t need to create commits or branches for each one: Only when you decide which of these experiments are worth sharing with the team, you can convert them into actual Git branches: Single-command reproducibility Finally, codifying the entire experiment pipeline is a good first step towards reproducibility, but it still leaves it to the user to execute that pipeline. With DVC you can reproduce the entire experiment with a single command. Not only that, but it will check for cached inputs and outputs and skip recomputing data that’s been generated before which can be a massive time saver at times. Conclusion To summarize, experiment versioning allows you to codify your experiments in such a way that your experiment logs are always connected to the exact data, code, and pipeline that went into the experiment. You have control over which experiments end up shared with your colleagues for comparison, and this can prevent clutter. Finally, reproducing a versioned experiment becomes as easy as running a single command, and it can even take less time than initially, if some of the pipeline steps have cached outputs that are still relevant. Thanks for reading! And if you want to learn more about versioning machine learning experiments, check out . DVC docs Also published . here

How to Version Machine Learning Experiments Instead of Tracking Them

[Pic] The classic legend of dual-use nature exploiting institutional ambiguities, sitting in the ruins of a medieval empire. A couple of years ago, the US put a worldwide export control on convolutional neural network based geospatial imagery software, the reason being its potential use by foreign militaries. It is worth noting that these are commercial software products which if open-sourced, their hardware dependencies aside, would not be treated under international jurisprudence as products but instead as free-speech. Which brings us to the subject of export controls, dual-use emerging technologies, and legacy international institutions. quietly Technology Export & Information Export-control in itself is an old and important tool of statecraft, serving economic as well as military functions. However the present dichotomous classification of technologies based on military and non-military usage is severely outdated and in fact only holds-up when dealing with conventional weapons. AI in itself isn't a weapon but an enabler and having AI-superiority proves hugely advantageous when extending general capabilities across all kinds of defense systems and platforms, giving the machine learning software-stack and hardware accelerators a strong military utility. To deal with the problematic usage of such dual-use technologies, the most prominent international regime is the . The arrangement, with respect to its fundamental role of helping to prevent the malicious use of technology, is pretty ineffectual when it comes to Artificial Intelligence and its ICT based applications. The de-territorializing effects of cyberspace present a clear institutional, regulatory, and compliance gap, where arrangements like Wassenaar only end up imposing yesterday’s standards over tomorrow’s technology. For example the first time when Wassenaar was invoked, it targeted software during the 90s to stop international adoption of cryptographic techniques over things like e-mail communications. That turned out to be a lot more than just diplomatic failure. Wassenaar Arrangement And Wassenaar isn't the only international regime facing difficulty with technological changes. The MTCR (Missile Technology Control Regime) for example has been updated to include long range UAVs and future changes sooner than later. It must be made clear that these controls do not work as intended. There is always great difficulty in enforcing contracts in emerging markets, there is an ever-present tradeoff between transparency and secrecy, and moreover in an environment of deception the compliance can not be truly verified even if states bring (they do) their own technical means of verification. This is a grand version of what game theorists call a POSG (Partial Observation Stochastic Game), really fascinating and quite intractable stuff. will need Scholars have duly noted the inherent in Wassenaar Arrangement, especially when dealing with intangible dual-use technologies. There is no consensus on whether the arrangement could adapt to technologies which are both socioeconomically foundational and militarily significant, without ironically turning itself into a dual-use multilateral instrument of coercive and economic statecraft. ambiguity Such concerns are not unfounded in international politics, take for example when in 1993 the Americans got the Russians to cancel the transfer of cryogenic technologies to India in for some US-Russia space cooperation. Software being fundamentally information, presents more compounded challenges for export controls given the largely unregulated flow of information across borders. Basically the trouble being that if you put sanctions over the export of fishes to someone, failing to prevent him from learning to fish is a foreign policy failure. exchange Not surprisingly therefore, a recent US AI-policy which declared advertising-technologies as "NatSecTech", also contained that "Export controls should be utilized... to slow competitors’ efforts to develop indigenous industries in sensitive technologies with defense applications... (by) targeting discrete choke-points." report Proliferation & The Undefined The Mahabharat is absolutely filled with instances of specialized and more devastating tools being limited-by-distribution to only select few, though those familiar with the text would concur that this non-proliferation regime did little to control privileged actor behavior and eventually an utterly morbid devastation followed up. Multilateral export control regimes today pursue a deterrence by denial framework towards global security. However, in case of ICT based goods when export controls suppress economic interests, proliferation shifts to a black market, even between member states, on shady darknet sites. It takes no genius to see that legally binding restrictions on AI capabilities will be economically debilitating, so it is going to be really hard to enforce sovereignty over technology or even know which exact technologies to control. Let us consider a hypothetical scenario: Most of the (>90%) in AI operation happens due to what can be described as "data movement operations" — adjusting features, weights, biases, transferring intermediate results etc — so it is understandable that a  better power management technique/toolkit could make the systems significantly more energy efficient. power consumption Now consider that in a not-too-distant future these computations are happening in autonomous edge devices fielded on both sides amid a lengthy military standoff in a remote inhospitable region such as the deserted upper reaches of the Himalayas. Would an innovative intangible power model here be treated the same way an advanced battery technology is treated? What if someone strategically open-sources it? Given that even technologies used today in public transportation, agriculture and pollution monitoring, such as LIDAR and hyperspectral tracking, will be very easily directed to military usage; several researchers have to use the phrase "omni-use" to describe AI and other related emerging ecosystem. It should be clear to whomsoever-it-may-concern that they cannot control the flow of omni-use intangible items and neither can it be ascertained decidedly what or from who an omni-use technology must be kept. In an area like this, traditional controls will only bring about regulations and more of other unsavory economics. suggested shadow Way Forward, Institutional Corrigibility Most countries with strong R&D focus prefer their weapon-systems to be approached as black-boxes, not to be reversed engineered or subjected to exhaustive component analysis. On another side, in future insurgencies and urban conflicts, we could be seeing a lot of improvised weapon systems which utilize open-source and low cost OTS components, those which would just not be regulated with current approaches. What technologies are available to militaries greatly guides how societies evolve and technologies also have a tendency to become more efficient relatively quickly because of their near-constant evolutionary cycle of adaptation and reinvention. It is therefore fitting and important to have a better and continuous coupling with all stakeholders, and not get carried away by media headlines, trends and lobbying. So building Institutional in our context can be thought of as designing mechanisms to facilitate objective stakeholders (from academia and industry) bring necessary outside correction in transgovernmental networks responsible for developing and implementing technology export controls. Corrigibility The multilateral international institutions must understand and absorb the difference between essential system complexity and accidental system complexity, and work every bit to minimize and first and obliterate the second. Previously published at https://muskdeer.blogspot.com/2021/03/the-narcissism-of-technical-differences.html

On Export Controls And Dual-use Emerging Technologies

A few days ago, . Specifically, the new releases focuses on tuning and optimizing hyperparameters associated with SageMaker models. The release constitutes a powerful addition in order to streamline the adoption of SageMaker within the data science community. With the new hyperparameter tuning and model optimization capabilities, SageMaker joins a new group of platforms that are entering the market trying to solve this notorious challenge in deep learning applications. Amazon announced the availability of a new set of automatic model tuning capabilities in the AWS SageMaker platform Building deep learning solutions in the real world is a process of constant experimentation and optimization. Differently from any other type of software application, deep learning applications don’t have a linear lifecycle based on the fact that models need to constantly refined, optimized and tested. What are Hyperparameters? Among the possible optimizations in a deep learning model, none plays a more prominent role that the tuning of hyperparameters. Conceptually, hyperparameters are variables that, while external to the model, influence its behavior and knowledge. A mid-size deep learning model, can be influenced by many hyperparameters including some of the following: · The mother of all hyperparameters, the learning rate quantifies the learning progress of a model in a way that can be used to optimize its capacity. Learning Rate: · A classic hyperparameter in deep learning algorithms, the number of hidden units is key to regulate the representational capacity of a model. Number of Hidden Units: · In convolutional Neural Networks(CNNs), the Kernel Width influences the number of parameters in a model which, in turns, influences its capacity. Convolution Kernel Width: · This hyperparameter helps to know the direction of the next step with the knowledge of the previous steps. It helps to prevent oscillations. Momentum: · Mini batch size is the number of sub samples given to the network after which parameter update happens. Batch Size: The Players Tuning hyperparameters in a deep learning application can be an incredibly challenging process given that it requires not only the execution of an experiment but the evaluation of the results against other versions of the model. Recently, there are a new group of platforms that have entered the market with the surgical focus on solving this challenge across different deep learning frameworks. Let’s look at a few of the most prominent solutions in this new space: SageMaker With its latest release, SageMaker incorporates the creation of hyperparameter tuning jobs directly in the SageMaker console. The platform performs the evaluation and comparison of the different hyperparameter models and directly integrates with the training jobs and other aspects of the model lifecycle. Comet.ml Comet.ml provides a super simple interface for the tuning and optimization of hyperparameters across different deep learning frameworks such as TensorFlow, Keras, PyTorch, Scikit-Learn and many others. Developers can seamlessly integrate Comet.ml into their models using the several SDKs available with the platform as well as the REST API. The platform provides a very visual way to tune and evaluate hyperparameters. Weights&Biases One of my favorite stacks when comes to hyperparameter tuning is the newly released Weights&Biases(W&B). Used by deep learning power houses such as OpenAI, W&B provides an advanced toolset and programming model for recording and tuning hyperparameters across different experiments. The solution records and visualizes the different steps in the execution of the model and correlates it with the configuration of its hyperparameters DeepCognition DeepCognition is one of the new platforms making inroads in the world of self-service deep learning. Functionally, DeepCognition enables the implementation, training and optimization of deep learning models with minimum coding. As part of the optimization process, DeepCognition includes a very powerful and visual hyperparameter tuning engine that records and compares the execution of experiments based on specific hyperparameter configurations. Azure ML Azure ML provides native hyperparameter tuning capabilities as part of its ML Studio. While the existing functionality seems limited compared to some of the other options covered in this article, the platform is able to record and provide basic visualizations relevant to the model hyperparameters. The hyperparameter tuning capabilities of Azure ML can be combined with other services such as to streamline the creation and testing of new experiments. Azure ML Experimentation Cloud ML Just like AWS SageMaker and Azure ML, Google Cloud ML provides some basic hyperparameter tuning capabilities as part of its platform. The current Cloud ML feature set is a bit limited compared to some of its competitors but Google has proven its ability to iterate faster in this space.

Stories, News & Mentions about WEIGHTS-BIASES

Weights-biases’s Stories on HackerNoon

Weights-biases's News & Mentions