Aista

aista

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Kiriaki Frangias;
(2) Andrew Lin;
(3) Ellen Vitercik;
(4) Manolis Zampetakis. Table of Links Abstract and Introduction Warm-up: Agents with known equal disutility Agents with unknown disutilites Experiments Conclusions and future directions, References A Summary of notation B Omitted proofs from Section 2 C Omitted proofs from Section 3 D Additional Information about Experiments 5 Conclusions and future directions We studied the multifaceted problem of designing a crowdsourcing mechanism that efficiently and accurately ranks a set of items using pairwise comparisons from rational agents. We based our approach on the classic principal-agent model from contract theory. To distribute comparisons among agents, we used an unexpected connection to the social golfer problem which allowed us to simultaneously minimize the agents’ workload and ensure enough agents evaluate each comparison. We showed that by optimizing the payment mechanisms, the principal can incentivize enough agents to exert effort, ensuring our algorithm recovers the ground-truth ranking. Our experiments showed that even when noise is added to our original model, our method consistently aids the principal in retrieving the accurate ground-truth ordering. llude, which allowed us to assign the same set of verified comparisons to all agents. How should our mechanism change if agents can collude? Moreover, we assumed that agents who do not exert effort will return comparisons consistent with a uniformly-random permutation of the items. What other models of agent behavior can we study under this framework? Finally, as is standard in contract theory, we assumed that the principal knows the probability π that an effortful agent is good. How should we handle the case where π is unknown? References [1] Abolfazl Asudeh, Gensheng Zhang, Naeemul Hassan, Chengkai Li, and Gergely V. Zaruba. Crowdsourcing pareto-optimal object finding by pairwise comparisons. In Proceedings of the 24th ACM International on Conference on Information and Knowledge Management (CIKM), 2015. [2] Ralph Allan Bradley and Milton E Terry. Rank analysis of incomplete block designs: I. the method of paired comparisons. Biometrika, 39(3/4):324–345, 1952. [3] Yang Cai, Constantinos Daskalakis, and Christos Papadimitriou. Optimum statistical estimation with strategic data sources. In Conference on Learning Theory (COLT), 2015. [4] Xi Chen, Paul N Bennett, Kevyn Collins-Thompson, and Eric Horvitz. Pairwise ranking aggregation in a crowdsourced setting. In Proceedings of the International Conference on Web Search and Data Mining, pages 193–202, 2013. [5] Yuxin Chen and Changho Suh. Spectral MLE: Top-k rank aggregation from pairwise comparisons. In International Conference on Machine Learning (ICML), 2015. [6] Paul Duetting, Tomer Ezra, Michal Feldman, and Thomas Kesselheim. Combinatorial contracts. In Symposium on Foundations of Computer Science (FOCS), 2022. [7] Anindya Ghose, Panagiotis G Ipeirotis, and Beibei Li. Designing ranking systems for hotels on travel search engines by mining user-generated and crowdsourced content. Marketing Science, 31(3):493–520, 2012. [8] John Guiver and Edward Snelson. Bayesian inference for plackett-luce ranking models. In International Conference on Machine Learning (ICML), 2009. [9] Stephen Guo, Aditya Parameswaran, and Hector Garcia-Molina. So who won? dynamic max discovery with the crowd. In Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data, SIGMOD ’12, page 385–396, New York, NY, USA, 2012. Association for Computing Machinery. ISBN 9781450312479. doi: 10.1145/2213836.2213880. URL https://doi.org/10.1145/2213836.2213880. [10] Guru Guruganesh, Jon Schneider, and Joshua Wang. Contracts under moral hazard and adverse selection. In ACM Conference on Economics and Computation (EC), 2021. [11] R. Jurca and B. Faltings. Mechanisms for making crowds truthful. Journal of Artificial Intelligence Research, 34:209–253, mar 2009. doi: 10.1613/jair.2621. URL https://doi.org/10.1613%2Fjair.2621. [12] Radu Jurca and Boi Faltings. Robust incentive-compatible feedback payments. In Workshop on Trading Agent Design and Analysis, 2006. [13] Radu Jurca and Boi Faltings. Minimum payments that reward honest reputation feedback. In ACM Conference on Economics and Computation (EC), 2006. [14] Jiawen Kang, Zehui Xiong, Dusit Niyato, Dongdong Ye, Dong In Kim, and Jun Zhao. Toward secure blockchain-enabled internet of vehicles: Optimizing consensus management using reputation and contract theory. IEEE Transactions on Vehicular Technology, 68(3):2906–2920, 2019. [15] Ngai Meng Kou, Yan Li, Hao Wang, Leong Hou U, and Zhiguo Gong. Crowdsourced top-k queries by confidence-aware pairwise judgments. Proceedings of the 2017 ACM International Conference on Management of Data, 2017. URL https://api.semanticscholar.org/CorpusID:36647621. [16] Jean-Jacques Laffont and David Martimort. Moral Hazard: The Basic Trade-Offs, pages 145–186. Princeton University Press, 2002. URL http://www.jstor.org/stable/j.ctv7h0rwr.8. [17] Shili Lin. Rank aggregation methods. Wiley Interdisciplinary Reviews: Computational Statistics, 2(5):555–570, 2010. [18] Tyler Lu and Craig Boutilier. Learning mallows models with pairwise preferences. In International Conference on Machine Learning (ICML), 2011. [19] C. L. Mallows. Non-null ranking models. i. Biometrika, 44:114–130, 1957. URL https://api.semanticscholar.org/CorpusID:121527283. [20] Fei Mi and Dit-Yan Yeung. Probabilistic graphical models for boosting cardinal and ordinal peer grading in moocs. In AAAI Conference on Artificial Intelligence, 2015. [21] Chris Piech, Jonathan Huang, Zhenghao Chen, Chuong Do, Andrew Ng, and Daphne Koller. Tuned models of peer assessment in moocs. In Proceedings of The 6th International Conference on Educational Data Mining (EDM), 2013. [22] R. L. Plackett. The Analysis of Permutations. Journal of the Royal Statistical Society Series C, 24(2):193–202, June 1975. doi: 10.2307/2346567. URL https://ideas.repec.org/a/bla/jorssc/v24y1975i2p193-202.html. [23] Karthik Raman and Thorsten Joachims. Methods for ordinal peer grading. In International Conference on Knowledge Discovery and Data Mining (KDD), 2014. [24] Karthik Raman and Thorsten Joachims. Bayesian ordinal peer grading. In Proceedings of the ACM Conference on Learning at Scale, 2015. [25] Vikas C Raykar, Shipeng Yu, Linda H Zhao, Gerardo Hermosillo Valadez, Charles Florin, Luca Bogoni, and Linda Moy. Learning from crowds. Journal of machine learning research, 11(4), 2010. [26] Nihar Shah, Sivaraman Balakrishnan, Joseph Bradley, Abhay Parekh, Kannan Ramchandran, and Martin Wainwright. Estimation from Pairwise Comparisons: Sharp Minimax Bounds with Topology Dependence. In International Conference on Artificial Intelligence and Statistics (AISTATS), 2015. [27] Nihar B Shah, Joseph K Bradley, Abhay Parekh, Martin Wainwright, and Kannan Ramchandran. A case for ordinal peer-evaluation in moocs. In NIPS Workshop on Data-Driven Education, 2013. [28] Louis Leon Thurstone. The method of paired comparisons for social values. The Journal of Abnormal and Social Psychology, 21:384–400, 1927. URL https://api.semanticscholar.org/CorpusID:144595330. [29] Markus Triska. Solution Methods for the Social Golfer Problem. PhD thesis, Vienna University of Technology, March 2008. Available from https://www.metalevel.at/mst.pdf. [30] Kristi Tsukida, Maya R Gupta, et al. How to analyze paired comparison data. Department of Electrical Engineering University of Washington, Tech. Rep. UWEETR-2011-0004, 1, 2011. [31] Bo Waggoner and Yiling Chen. Output agreement mechanisms and common knowledge. Proceedings of the AAAI Conference on Human Computation and Crowdsourcing, 2(1): 220–226, Sep. 2014. doi: 10.1609/hcomp.v2i1.13151. URL https://ojs.aaai.org/index.php/HCOMP/article/view/13151. [32] Banghua Zhu, Stephen Bates, Zhuoran Yang, Yixin Wang, Jiantao Jiao, and Michael I. Jordan. The sample complexity of online contract design. In ACM Conference on Economics and Computation (EC), 2023. This paper is available on Arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. Authors: (1) Kiriaki Frangias; (2) Andrew Lin; (3) Ellen Vitercik; (4) Manolis Zampetakis. This paper is available on arxiv under CC 4.0 license. Authors : Authors (1) Kiriaki Frangias; (2) Andrew Lin; (3) Ellen Vitercik; (4) Manolis Zampetakis. Table of Links Abstract and Introduction Abstract and Introduction Warm-up: Agents with known equal disutility Warm-up: Agents with known equal disutility Agents with unknown disutilites Agents with unknown disutilites Experiments Experiments Conclusions and future directions, References Conclusions and future directions, References A Summary of notation A Summary of notation B Omitted proofs from Section 2 B Omitted proofs from Section 2 C Omitted proofs from Section 3 C Omitted proofs from Section 3 D Additional Information about Experiments D Additional Information about Experiments 5 Conclusions and future directions We studied the multifaceted problem of designing a crowdsourcing mechanism that efficiently and accurately ranks a set of items using pairwise comparisons from rational agents. We based our approach on the classic principal-agent model from contract theory. To distribute comparisons among agents, we used an unexpected connection to the social golfer problem which allowed us to simultaneously minimize the agents’ workload and ensure enough agents evaluate each comparison. We showed that by optimizing the payment mechanisms, the principal can incentivize enough agents to exert effort, ensuring our algorithm recovers the ground-truth ranking. Our experiments showed that even when noise is added to our original model, our method consistently aids the principal in retrieving the accurate ground-truth ordering. llude, which allowed us to assign the same set of verified comparisons to all agents. How should our mechanism change if agents can collude? Moreover, we assumed that agents who do not exert effort will return comparisons consistent with a uniformly-random permutation of the items. What other models of agent behavior can we study under this framework? Finally, as is standard in contract theory, we assumed that the principal knows the probability π that an effortful agent is good. How should we handle the case where π is unknown? References [1] Abolfazl Asudeh, Gensheng Zhang, Naeemul Hassan, Chengkai Li, and Gergely V. Zaruba. Crowdsourcing pareto-optimal object finding by pairwise comparisons. In Proceedings of the 24th ACM International on Conference on Information and Knowledge Management (CIKM), 2015. [2] Ralph Allan Bradley and Milton E Terry. Rank analysis of incomplete block designs: I. the method of paired comparisons. Biometrika, 39(3/4):324–345, 1952. [3] Yang Cai, Constantinos Daskalakis, and Christos Papadimitriou. Optimum statistical estimation with strategic data sources. In Conference on Learning Theory (COLT), 2015. [4] Xi Chen, Paul N Bennett, Kevyn Collins-Thompson, and Eric Horvitz. Pairwise ranking aggregation in a crowdsourced setting. In Proceedings of the International Conference on Web Search and Data Mining, pages 193–202, 2013. [5] Yuxin Chen and Changho Suh. Spectral MLE: Top-k rank aggregation from pairwise comparisons. In International Conference on Machine Learning (ICML), 2015. [6] Paul Duetting, Tomer Ezra, Michal Feldman, and Thomas Kesselheim. Combinatorial contracts. In Symposium on Foundations of Computer Science (FOCS), 2022. [7] Anindya Ghose, Panagiotis G Ipeirotis, and Beibei Li. Designing ranking systems for hotels on travel search engines by mining user-generated and crowdsourced content. Marketing Science, 31(3):493–520, 2012. [8] John Guiver and Edward Snelson. Bayesian inference for plackett-luce ranking models. In International Conference on Machine Learning (ICML), 2009. [9] Stephen Guo, Aditya Parameswaran, and Hector Garcia-Molina. So who won? dynamic max discovery with the crowd. In Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data, SIGMOD ’12, page 385–396, New York, NY, USA, 2012. Association for Computing Machinery. ISBN 9781450312479. doi: 10.1145/2213836.2213880. URL https://doi.org/10.1145/2213836.2213880. [10] Guru Guruganesh, Jon Schneider, and Joshua Wang. Contracts under moral hazard and adverse selection. In ACM Conference on Economics and Computation (EC), 2021. [11] R. Jurca and B. Faltings. Mechanisms for making crowds truthful. Journal of Artificial Intelligence Research, 34:209–253, mar 2009. doi: 10.1613/jair.2621. URL https://doi.org/10.1613%2Fjair.2621. [12] Radu Jurca and Boi Faltings. Robust incentive-compatible feedback payments. In Workshop on Trading Agent Design and Analysis, 2006. [13] Radu Jurca and Boi Faltings. Minimum payments that reward honest reputation feedback. In ACM Conference on Economics and Computation (EC), 2006. [14] Jiawen Kang, Zehui Xiong, Dusit Niyato, Dongdong Ye, Dong In Kim, and Jun Zhao. Toward secure blockchain-enabled internet of vehicles: Optimizing consensus management using reputation and contract theory. IEEE Transactions on Vehicular Technology, 68(3):2906–2920, 2019. [15] Ngai Meng Kou, Yan Li, Hao Wang, Leong Hou U, and Zhiguo Gong. Crowdsourced top-k queries by confidence-aware pairwise judgments. Proceedings of the 2017 ACM International Conference on Management of Data, 2017. URL https://api.semanticscholar.org/CorpusID:36647621. [16] Jean-Jacques Laffont and David Martimort. Moral Hazard: The Basic Trade-Offs, pages 145–186. Princeton University Press, 2002. URL http://www.jstor.org/stable/j.ctv7h0rwr.8. [17] Shili Lin. Rank aggregation methods. Wiley Interdisciplinary Reviews: Computational Statistics, 2(5):555–570, 2010. [18] Tyler Lu and Craig Boutilier. Learning mallows models with pairwise preferences. In International Conference on Machine Learning (ICML), 2011. [19] C. L. Mallows. Non-null ranking models. i. Biometrika, 44:114–130, 1957. URL https://api.semanticscholar.org/CorpusID:121527283. [20] Fei Mi and Dit-Yan Yeung. Probabilistic graphical models for boosting cardinal and ordinal peer grading in moocs. In AAAI Conference on Artificial Intelligence, 2015. [21] Chris Piech, Jonathan Huang, Zhenghao Chen, Chuong Do, Andrew Ng, and Daphne Koller. Tuned models of peer assessment in moocs. In Proceedings of The 6th International Conference on Educational Data Mining (EDM), 2013. [22] R. L. Plackett. The Analysis of Permutations. Journal of the Royal Statistical Society Series C, 24(2):193–202, June 1975. doi: 10.2307/2346567. URL https://ideas.repec.org/a/bla/jorssc/v24y1975i2p193-202.html. [23] Karthik Raman and Thorsten Joachims. Methods for ordinal peer grading. In International Conference on Knowledge Discovery and Data Mining (KDD), 2014. [24] Karthik Raman and Thorsten Joachims. Bayesian ordinal peer grading. In Proceedings of the ACM Conference on Learning at Scale, 2015. [25] Vikas C Raykar, Shipeng Yu, Linda H Zhao, Gerardo Hermosillo Valadez, Charles Florin, Luca Bogoni, and Linda Moy. Learning from crowds. Journal of machine learning research, 11(4), 2010. [26] Nihar Shah, Sivaraman Balakrishnan, Joseph Bradley, Abhay Parekh, Kannan Ramchandran, and Martin Wainwright. Estimation from Pairwise Comparisons: Sharp Minimax Bounds with Topology Dependence. In International Conference on Artificial Intelligence and Statistics (AISTATS), 2015. [27] Nihar B Shah, Joseph K Bradley, Abhay Parekh, Martin Wainwright, and Kannan Ramchandran. A case for ordinal peer-evaluation in moocs. In NIPS Workshop on Data-Driven Education, 2013. [28] Louis Leon Thurstone. The method of paired comparisons for social values. The Journal of Abnormal and Social Psychology, 21:384–400, 1927. URL https://api.semanticscholar.org/CorpusID:144595330. [29] Markus Triska. Solution Methods for the Social Golfer Problem. PhD thesis, Vienna University of Technology, March 2008. Available from https://www.metalevel.at/mst.pdf. [30] Kristi Tsukida, Maya R Gupta, et al. How to analyze paired comparison data. Department of Electrical Engineering University of Washington, Tech. Rep. UWEETR-2011-0004, 1, 2011. [31] Bo Waggoner and Yiling Chen. Output agreement mechanisms and common knowledge. Proceedings of the AAAI Conference on Human Computation and Crowdsourcing, 2(1): 220–226, Sep. 2014. doi: 10.1609/hcomp.v2i1.13151. URL https://ojs.aaai.org/index.php/HCOMP/article/view/13151. [32] Banghua Zhu, Stephen Bates, Zhuoran Yang, Yixin Wang, Jiantao Jiao, and Michael I. Jordan. The sample complexity of online contract design. In ACM Conference on Economics and Computation (EC), 2023. This paper is available on Arxiv under CC 4.0 license. This paper is available on Arxiv under CC 4.0 license. Arxiv

Algorithmic Contract Design for Crowdsourced Ranking: Conclusions, Future Directions, and References

Retrieval-Augmented Generation (RAG) blends the generative abilities of LLMs with the retrieval of information from diverse knowledge bases (KBs). However, traditional implementations of RAG have often relied on pre-scripting the logic for selecting and utilizing these KBs. This conventional method, while effective, places limits on the flexibility and adaptability, and performance of the applications. But consider an alternative: applications that empower the LLM itself to determine which actions are necessary to generate a response. This approach not only harnesses the LLM's generative capabilities but also its ability to make contextual decisions on-the-fly, thereby opening up a more dynamic and responsive way to handle knowledge search tasks. As a result, you can build targeted KB's and use the power of LLMs to write application-specific queries that retrieve better, more relevant results. To demonstrate this approach, we'll build backed by a custom tool.
The chatbot will have access to a KB containing product information - any time you ask a question the chatbot determines could be answered using this tool it will query the KB and show both the in-progress query and retrieved results as custom UI elements before responding with the retrieved products as context. a simple chatbot We'll use Vercel's to render the chat window and Dewy to implement the information storage and retrieval used by our tool and as the knowledge store backing the tool. Generative UI library Dewy Why Dewy and Vercel? is designed to simplify the creation of custom LLM "tools" and to render rich, interactive UI elements that are specific to each tool the LLM chooses to use. Vercel's Generative UI library) What this means in practice is that your UI can dynamically adapt to the specific tools chosen by the LLM, displaying tool-specific information and progress indicators to the user. is an OSS knowledge base with the simplicity and ease-of-use of a document store: insert your documents and Dewy takes care of preparing them for semantic search.
Dewy's flexibility and ease of use allow developers to focus on building amazing user experiences rather than complex data-processing pipelines. Dewy Prerequisites Before diving into the tutorial, ensure you have the following prerequisites covered: Basic knowledge of Typescript and React A NextJS environment setup on your local machine A copy of Dewy running on your local machine (see Dewy's if you need help here). installation instructions Access to the platform. OpenAI API Set up your project : Create a NextJS app by running the following command in your terminal: Initialize a new NextJS project pnpm dlx create-next-app@canary rag-tool Navigate into your new project directory: cd rag-tool : Next, we'll install , Vercel's AI library, , OpenAI's official JavaScript SDK compatible with the Vercel Edge Runtime, and , the Dewy client library. Zod will be used to describe the input types for our custom tool. Install required packages ai openai dewy-ts pnpm install ai openai zod dewy-ts : Configure your OpenAI key and Dewy endpoint. Prepare your environment touch .env.local OPENAI_API_KEY=xxxxxxxxx
DEWY_ENDPOINT=localhost:8000 Create a custom tool First, create the custom tool the LLM will use to answer product-related questions.
This tool describes its purpose and parameters so the LLM knows when and how to use it, and defines the implementation and UI logic to complete the tool invocation. In this case, the tool will "get information about products", given a search query and a result count. When the LLM determines this tool should be used, it will generate the query string and choose how many results are appropriate, then execute the function defined below. render On execution, the tool searches Dewy for relevant products, then calls the LLM again to pick up where it left off. Since this process can take awhile, the function 's components indicating that the tool is being used and its progress. These components allow the UI to reflect the specific information relevant to this tool's outcomes. render yield import { z } from 'zod';
import { Dewy } from 'dewy-ts';
import { OpenAIStream } from 'ai'
import { Tokens } from 'ai/react';

import AssistantMessage from './AssistantMessage';
import ResultCard from './ResultCard';
import SearchCard from './SearchCard';

// Create a Dewy client.
const dewy = new Dewy({
    BASE: process.env.DEWY_ENDPOINT
})

// Implement the tool's logic.
// In this case, we search for the given query
// and return the `count` most similar chunks in the KB.
// The returned chunks are used in the `render` method below.
async function searchProducts(query: string, count: number) {
    const context = await dewy.kb.retrieveChunks({
        collection: "product_info",
        query: query,
        n: count,
    })
    return context.text_results.map(c => c.text)
}

// Define the behavior of the product search tool.
export default function productSearch(aiState, openai) {
    return {
        // A description of the tool.
        // This used by the LLM to decide when to use the tool
        description: 'Get information about products',

        // Parameters control how the tool behaves.
        // These values will be picked by the LLM,
        // so be sure to clearly explain what they're
        // used for.
        parameters: z.object({
            query: z.string().describe(```
                A description of a product 
                or what the product can be used for.
            ```),
            count: z.number().describe(```
                The number of products to return.
            ```),
        }).required(),

        // Configure the tool's behavior.
        // This function will be called after the LLM has
        // chosen to use the tool and generated values for
        // the parameters we configured above.
        render: async function* ({ query, count }) {
            // Let the user know we're looking for 
            // products related to their message
            yield <SearchCard query={query} count={count} />

            // Search for products related to the user's question
            const products = await searchProducts(query, count)

            // Update the message history 
            // with the results we found
            aiState.update([
                ...aiState.get(),
                {
                    role: "function",
                    name: "product_search",
                    content: JSON.stringify(products),
                }
            ]);

            // Now reply to the user.
            // The products we retrieved are part of the state 
            // provided as the messages parameter
            const resp = await openai.chat.completions.create({
                model: 'gpt-4-0125-preview',
                messages: aiState.get(),
                stream: true,
            })

            // Stream the results back as they're generated
            const stream = OpenAIStream(resp, {
                onFinal: (completion) => {
                    // Update the conversation history 
                    // once the full response is received
                    aiState.done([
                        ...aiState.get(),
                        {
                            role: "assistant",
                            content: completion,
                        }
                    ])
                }
            });

            // Display the response alongside 
            // the products provided to the model.
            return <div className="flex flex-col gap-2">
                <ResultCard query={query} results={context} />
                <AssistantMessage>
                    <Tokens stream={stream} />
                </AssistantMessage>
            </div>
        }
    }
} Setup the server-side message handler Configure a message handling action to receive new messages from the client.
This handler configures the initial state of the chatbot and defines the server's behavior when a message is received from the user. import { OpenAI } from 'openai';
import { createAI, createStreamableUI, getMutableAIState, render } from 'ai/rsc';

import productSearch from './productSearch';
import AssistantMessage from './AssistantMessage';

// Configure the LLM, in this case OpenAI
const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});
 
async function submitUserMessage(userInput: string) {
  'use server';
 
  // The AI state. This contains our message history,
  // and will be provided to the LLM each time a 
  // chat completion is generated.
  const aiState = getMutableAIState<typeof AI>();
  aiState.update([
    ...aiState.get(),
    {
      role: 'user',
      content: userInput,
    },
  ]);
 
  // Helper function for building streamable UI components.
  const ui = render({
    model: 'gpt-4-0125-preview',
    provider: openai,
    messages: [
      { role: 'system', content: `
        You are a product recommendation engine. 
        Respond only with information about products 
        retrieved using the "product_search" function role.
        `},
      { role: 'user', content: userInput }
    ],

    // This determines how generated text 
    // (as opposed to function calls) will
    // be rendered.
    text: ({ content, done }) => {
      if (done) {
        aiState.done([
          ...aiState.get(),
          {
            role: "assistant",
            content
          }
        ]);
      }
      return <AssistantMessage>{content}</AssistantMessage>
    },

    // Configure the tools available to the LLM
    tools: {
      product_search: productSearch(aiState, openai),
    }
  })
 
  return {
    id: Date.now(),
    display: ui
  };
}
 
// Define the initial state of the AI. It can be any JSON object.
const initialAIState: {
  role: 'user' | 'assistant' | 'system' | 'function';
  content: string;
  id?: string;
  name?: string;
}[] = [];
 
// The initial UI state that the client will keep track of, which contains the message IDs and their UI nodes.
const initialUIState: {
  id: number;
  display: React.ReactNode;
}[] = [{id: 0, display: <AssistantMessage>Hi! How can I help you today?</AssistantMessage>}];
 
// AI is a provider you wrap your application with so you can access AI and UI state in your components.
export const AI = createAI({
  actions: {
    submitUserMessage
  },
  // Each state can be any shape of object, but for chat applications
  // it makes sense to have an array of messages. Or you may prefer something like { id: number, messages: Message[] }
  initialUIState,
  initialAIState
}); Setup the chat UI on the client Finally, set up the chat UI on the client. Map over the UI state's messages and insert their property. display Configure a form to update the AI state, then call the server side handler. submitUserMessage 'use client'
 
import { useState } from 'react';
import { useUIState, useActions } from 'ai/rsc';
import type { AI } from './action';
import { Input } from '@/components/ui/input';
import { Button } from '@/components/ui/button';
 
import UserMessage from './UserMessage';
import { PlaneIcon } from './icons';

export default function Page() {
  const [inputValue, setInputValue] = useState('');
  const [messages, setMessages] = useUIState<typeof AI>();
  const { submitUserMessage } = useActions<typeof AI>();
 
  return (
    <>
      <div className="flex-1 overflow-auto px-4 mt-4">
        <div className="grid gap-4 md:gap-8">
          {
            messages.map((message) => (
              <div key={message.id}>
                {message.display}
              </div>
            ))
          }

        </div>
      </div>

      <form onSubmit={async (e) => {
        e.preventDefault();

        // Add user message to UI state
        setMessages((currentMessages) => [
          ...currentMessages,
          {
            id: Date.now(),
            display: <UserMessage>{inputValue}</UserMessage>,
          },
        ]);

        // Submit and get response message
        const responseMessage = await submitUserMessage(inputValue);
        setMessages((currentMessages) => [
          ...currentMessages,
          responseMessage,
        ]);

        setInputValue('');
      }}>
        <div className="border-t-2">
          <div className="flex items-center h-14 px-4">
            <Input
              className="rounded-full flex-1 min-w-0 bg-gray-200 dark:bg-gray-800"
              placeholder="Type a message..."
              value={inputValue}
              type="text"
              onChange={(event) => {
                setInputValue(event.target.value)
              }}
            />
            <Button className="ml-2 h-8 w-8 rounded-full bg-gray-200 dark:bg-gray-800" size="icon">
              <PlaneIcon className="h-4 w-4" />
              <span className="sr-only">Send message</span>
            </Button>
          </div>
        </div>
      </form>
    </>
  )
} To keep this post from going any longer than it is already, several basic UI components have been omitted, but you can checkout the full implementation in the of the Dewy repo. examples directory Conclusion In conclusion, this blog post has guided you through the process of building a Retrieval-Augmented Generation (RAG) tool using Vercel's Generative UI components. This approach moves away from the traditional methods of pre-scripting logic for selecting and utilizing knowledge bases. By empowering the LLM to determine which knowledge bases are necessary and how best to use them, we've showcased a more dynamic, efficient, and user-centric way of handling information retrieval tasks. By utilizing Dewy as our knowledge base, we've emphasized the importance of a flexible, easy-to-use platform for storing, organizing, and retrieving information. This synergy between Dewy's streamlined data management and Vercel's dynamic UI rendering paves the way for developers to create more intelligent, responsive, and user-friendly applications. Also appears . here

How to Build a "RAG Tool" With Vercel's Generative UI Components

Authors: (1) Yunshan Ma, National University of Singapore; (2) Xiaohao Liu, University of Chinese Academy of Sciences; (3) Yinwei Wei, Monash University; (4) Zhulin Tao, Communication University of China and a Corresponding author; (5) Xiang Wang, University of Science and Technology of China and affiliated with Institute of Artificial Intelligence, Institute of Dataspace, Hefei Comprehensive National Science Center; (6) Tat-Seng Chua, National University of Singapore. Table of Links Abstract & Introduction Methodology Experiments Related Work Conclusion and Future Work, Acknowledgment and References 5 CONCLUSION AND FUTURE WORK In this work, we systematically study the problem of bundle construction and define a more comprehensive formulation by considering all the three types of data, i.e., multimodal features, item-level user feedback data, and existing bundles. Based on this formulation, we highlight two challenges: 1) how to learn expressive bundle representations given multiple features; and 2) how to counter the modality missing, noise, and sparity problem. To tackle these challenges, we propose a novel method of Contrastive Learningenhanced Hierarchical Encoder (CLHE) for bundle construction. Our method beats a list of leading methods on four datasets of two application domains. Extensive ablation and model studies justify the effectiveness of the key modules. Despite the great performance that has been achieved by this work, there is still large space to be explored for bundle construction. First, the current evaluation setting is a little bit rigid and inflexible, it is interesting to extend it to more flexible setting to align with real applications. For example, given arbitrary number of seed items, the model is asked to construct the bundle. Second, some of the feature extractors are pre-trained and fixed, i.e., the multimodal feature extraction and user-item interaction models. Is it possible to optimize these feature extractors in an end-to-end fashion thus the extracted features would be more aligned to the bundle construction task? Finally, this work just targets at unpersonalized bundle construction. It is an interesting and natural direction to push forward this work to personalized bundle construction. ACKNOWLEDGEMENT This research is supported by NExT Research Center, National Natural Science Foundation of China (9227010114), and the University Synergy Innovation Program of Anhui Province (GXXT-2022-040). REFERENCES [1] Jinze Bai, Chang Zhou, Junshuai Song, Xiaoru Qu, Weiting An, Zhao Li, and Jun Gao. 2019. Personalized Bundle List Recommendation. In WWW. ACM, 60–71. [2] Thierry Bertin-Mahieux, Daniel P.W. Ellis, Brian Whitman, and Paul Lamere. 2011. The Million Song Dataset. In Proceedings of the 12th International Conference on Music Information Retrieval (ISMIR 2011). [3] Tzoof Avny Brosh, Amit Livne, Oren Sar Shalom, Bracha Shapira, and Mark Last. 2022. BRUCE: Bundle Recommendation Using Contextualized item Embeddings. In RecSys. ACM, 237–245. [4] Da Cao, Liqiang Nie, Xiangnan He, Xiaochi Wei, Shunzhi Zhu, and Tat-Seng Chua. 2017. Embedding Factorization Models for Jointly Recommending Items and User Generated Lists. In SIGIR. ACM, 585–594. [5] Jianxin Chang, Chen Gao, Xiangnan He, Depeng Jin, and Yong Li. 2021. Bundle Recommendation and Generation with Graph Neural Networks. IEEE Transactions on Knowledge and Data Engineering (2021). [6] Jianxin Chang, Chen Gao, Xiangnan He, Depeng Jin, and Yong Li. 2023. Bundle Recommendation and Generation With Graph Neural Networks. IEEE Trans. Knowl. Data Eng. 35, 3 (2023), 2326–2340. [7] Ching-Wei Chen, Paul Lamere, Markus Schedl, and Hamed Zamani. 2018. Recsys challenge 2018: automatic music playlist continuation. In RecSys. ACM, 527–528. [8] Ke Chen, Xingjian Du, Bilei Zhu, Zejun Ma, Taylor Berg-Kirkpatrick, and Shlomo Dubnov. 2022. HTS-AT: A Hierarchical Token-Semantic Audio Transformer for Sound Classification and Detection. In ICASSP. IEEE, 646–650. [9] Liang Chen, Yang Liu, Xiangnan He, Lianli Gao, and Zibin Zheng. 2019. Matching User with Item Set: Collaborative Bundle Recommendation with Deep Attention Network.. In IJCAI. 2095–2101. [10] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey E. Hinton. 2020. A Simple Framework for Contrastive Learning of Visual Representations. In ICML (Proceedings of Machine Learning Research, Vol. 119). PMLR, 1597–1607. [11] Wen Chen, Pipei Huang, Jiaming Xu, Xin Guo, Cheng Guo, Fei Sun, Chao Li, Andreas Pfadler, Huan Zhao, and Binqiang Zhao. 2019. POG: Personalized Outfit Generation for Fashion Recommendation at Alibaba iFashion. In KDD. ACM, 2662–2670. [12] Zeyu Cui, Zekun Li, Shu Wu, Xiaoyu Zhang, and Liang Wang. 2019. Dressing as a Whole: Outfit Compatibility Learning Based on Node-wise Graph Neural Networks. In WWW. ACM, 307–317. [13] Qilin Deng, Kai Wang, Minghao Zhao, Runze Wu, Yu Ding, Zhene Zou, Yue Shang, Jianrong Tao, and Changjie Fan. 2021. Build Your Own Bundle - A Neural Combinatorial Optimization Method. In ACM MM. ACM, 2625–2633. [14] Qilin Deng, Kai Wang, Minghao Zhao, Zhene Zou, Runze Wu, Jianrong Tao, Changjie Fan, and Liang Chen. 2020. Personalized Bundle Recommendation in Online Games. In CIKM. ACM, 2381–2388. [15] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. In NAACL-HLT (1). Association for Computational Linguistics, 4171–4186. [16] Yujuan Ding, Yunshan Ma, Wai Keung Wong, and Tat-Seng Chua. 2021. Leveraging Two Types of Global Graph for Sequential Fashion Recommendation. In ICMR. ACM, 73–81. [17] Yujuan Ding, PY Mok, Yunshan Ma, and Yi Bin. 2023. Personalized fashion outfit generation with user coordination preference learning. Information Processing & Management 60, 5 (2023), 103434. [18] Tianyu Gao, Xingcheng Yao, and Danqi Chen. 2021. SimCSE: Simple Contrastive Learning of Sentence Embeddings. In EMNLP (1). Association for Computational Linguistics, 6894–6910. [19] Xavier Glorot and Yoshua Bengio. 2010. Understanding the difficulty of training deep feedforward neural networks. In AISTATS (JMLR Proceedings, Vol. 9). JMLR.org, 249–256. [20] Weili Guan, Haokun Wen, Xuemeng Song, Chung-Hsing Yeh, Xiaojun Chang, and Liqiang Nie. 2021. Multimodal Compatibility Modeling via Exploring the Consistent and Complementary Correlations. In ACM MM. ACM, 2299–2307. [21] Xintong Han, Zuxuan Wu, Yu-Gang Jiang, and Larry S. Davis. 2017. Learning Fashion Compatibility with Bidirectional LSTMs. In ACM MM. ACM, 1078–1086. [22] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2016. Deep Residual Learning for Image Recognition. In CVPR. IEEE Computer Society, 770–778. [23] Xiangnan He, Kuan Deng, Xiang Wang, Yan Li, Yong-Dong Zhang, and Meng Wang. 2020. LightGCN: Simplifying and Powering Graph Convolution Network for Recommendation. In SIGIR. ACM, 639–648. [24] Yun He, Yin Zhang, Weiwen Liu, and James Caverlee. 2020. Consistency-Aware Recommendation for User-Generated Item List Continuation. In WSDM. ACM, 250–258. [25] Diederik P Kingma and Jimmy Ba. 2014. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980 (2014). [26] Qiuqiang Kong, Yin Cao, Turab Iqbal, Yuxuan Wang, Wenwu Wang, and Mark D. Plumbley. 2020. PANNs: Large-Scale Pretrained Audio Neural Networks for Audio Pattern Recognition. IEEE ACM Trans. Audio Speech Lang. Process. 28 (2020), 2880–2894. [27] Junnan Li, Dongxu Li, Caiming Xiong, and Steven C. H. Hoi. 2022. BLIP: Bootstrapping Language-Image Pre-training for Unified Vision-Language Understanding and Generation. In ICML (Proceedings of Machine Learning Research, Vol. 162). PMLR, 12888–12900. [28] Ming Li, Lin Li, Qing Xie, Jingling Yuan, and Xiaohui Tao. 2022. MealRec: A Meal Recommendation Dataset. CoRR abs/2205.12133 (2022). [29] Xingchen Li, Xiang Wang, Xiangnan He, Long Chen, Jun Xiao, and Tat-Seng Chua. 2020. Hierarchical Fashion Graph Network for Personalized Outfit Recommendation. In SIGIR. ACM, 159–168. [30] Yi Li, Jieming Zhu, Weiwen Liu, Liangcai Su, Guohao Cai, Qi Zhang, Ruiming Tang, Xi Xiao, and Xiuqiang He. 2022. PEAR: Personalized Re-ranking with Contextualized Transformer for Recommendation. In WWW (Companion Volume). ACM, 62–66. [31] Dawen Liang, Rahul G. Krishnan, Matthew D. Hoffman, and Tony Jebara. 2018. Variational Autoencoders for Collaborative Filtering. In WWW. ACM, 689–698. [32] Kwan Hui Lim, Jeffrey Chan, Christopher Leckie, and Shanika Karunasekera. 2018. Personalized trip recommendation for tourists based on user interests, points of interest visit durations and visit recency. Knowl. Inf. Syst. 54, 2 (2018), 375–406. [33] Yusan Lin, Maryam Moosaei, and Hao Yang. 2020. OutfitNet: Fashion Outfit Recommendation with Attention-Based Multiple Instance Learning. In WWW. ACM / IW3C2, 77–87. [34] Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019. RoBERTa: A Robustly Optimized BERT Pretraining Approach. CoRR abs/1907.11692 (2019). [35] Yong Liu, Susen Yang, Chenyi Lei, Guoxin Wang, Haihong Tang, Juyong Zhang, Aixin Sun, and Chunyan Miao. 2021. Pre-training Graph Transformer with Multimodal Side Information for Recommendation. In ACM MM. ACM, 2853– 2861. [36] Ze Liu, Yutong Lin, Yue Cao, Han Hu, Yixuan Wei, Zheng Zhang, Stephen Lin, and Baining Guo. 2021. Swin Transformer: Hierarchical Vision Transformer using Shifted Windows. In ICCV. IEEE, 9992–10002. [37] Yunshan Ma, Yingzhi He, An Zhang, Xiang Wang, and Tat-Seng Chua. 2022. CrossCBR: Cross-view Contrastive Learning for Bundle Recommendation. In KDD. ACM, 1233–1241. [38] Yuyang Ren, Haonan Zhang, Luoyi Fu, Xinbing Wang, and Chenghu Zhou. 2023. Distillation-Enhanced Graph Masked Autoencoders for Bundle Recommendation. In SIGIR. ACM, 1660–1669. [39] Steffen Rendle, Christoph Freudenthaler, and Lars Schmidt-Thieme. 2010. Factorizing personalized Markov chains for next-basket recommendation. In WWW. ACM, 811–820. [40] Rohan Sarkar, Navaneeth Bodla, Mariya I. Vasileva, Yen-Liang Lin, Anurag Beniwal, Alan Lu, and Gerard Medioni. 2023. OutfitTransformer: Learning Outfit Representations for Fashion Recommendation. In WACV. IEEE, 3590–3598. [41] Xuemeng Song, Shi-Ting Fang, Xiaolin Chen, Yinwei Wei, Zhongzhou Zhao, and Liqiang Nie. 2023. Modality-Oriented Graph Learning Toward Outfit Compatibility Modeling. IEEE Trans. Multim. 25 (2023), 856–867. [42] Zhu Sun, Jie Yang, Kaidong Feng, Hui Fang, Xinghua Qu, and Yew Soon Ong. 2022. Revisiting Bundle Recommendation: Datasets, Tasks, Challenges and Opportunities for Intent-aware Product Bundling. In SIGIR. ACM, 2900–2911. [43] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. 2017. Attention is All you Need. In NIPS. 5998–6008. [44] Penghui Wei, Shaoguo Liu, Xuanhua Yang, Liang Wang, and Bo Zheng. 2022. Towards Personalized Bundle Creative Generation with Contrastive NonAutoregressive Decoding. In SIGIR. ACM, 2634–2638. [45] Yinwei Wei, Wenqi Liu, Fan Liu, Xiang Wang, Liqiang Nie, and Tat-Seng Chua. 2023. LightGT: A Light Graph Transformer for Multimedia Recommendation. In Proceedings of the 46th International ACM SIGIR Conference on Research and Development in Information Retrieval. 1508–1517. [46] Yinwei Wei, Xiaohao Liu, Yunshan Ma, Xiang Wang, Liqiang Nie, and Tat-Seng Chua. 2023. Strategy-aware Bundle Recommender System. In SIGIR. ACM, 1198– 1207. [47] Yinwei Wei, Xiang Wang, Liqiang Nie, Xiangnan He, Richang Hong, and Tat-Seng Chua. 2019. MMGCN: Multi-modal Graph Convolution Network for Personalized Recommendation of Micro-video. In ACM MM. ACM, 1437–1445. [48] Yinwei Wei, Xiang Wang, Liqiang Nie, Shaoyu Li, Dingxian Wang, and Tat-Seng Chua. 2022. Causal inference for knowledge graph based recommendation. IEEE Transactions on Knowledge and Data Engineering (2022). [49] Jiancan Wu, Xiang Wang, Fuli Feng, Xiangnan He, Liang Chen, Jianxun Lian, and Xing Xie. 2021. Self-supervised Graph Learning for Recommendation. In SIGIR. ACM, 726–735. [50] Yusong Wu, Ke Chen, Tianyu Zhang, Yuchen Hui, Taylor Berg-Kirkpatrick, and Shlomo Dubnov. 2022. Large-scale Contrastive Language-Audio Pretraining with Feature Fusion and Keyword-to-Caption Augmentation. CoRR abs/2211.06687 (2022). [51] Yao Wu, Christopher DuBois, Alice X. Zheng, and Martin Ester. 2016. Collaborative Denoising Auto-Encoders for Top-N Recommender Systems. In WSDM. ACM, 153–162. [52] Xun Yang, Yunshan Ma, Lizi Liao, Meng Wang, and Tat-Seng Chua. 2019. TransNFCM: Translation-Based Neural Fashion Compatibility Modeling. In AAAI. AAAI Press, 403–410. [53] Junliang Yu, Xin Xia, Tong Chen, Lizhen Cui, Nguyen Quoc Viet Hung, and Hongzhi Yin. 2022. XSimGCL: Towards extremely simple graph contrastive learning for recommendation. arXiv preprint arXiv:2209.02544 (2022). [54] Zhouxin Yu, Jintang Li, Liang Chen, and Zibin Zheng. 2022. Unifying multiassociations through hypergraph for bundle recommendation. Knowl. Based Syst. 255 (2022), 109755. [55] Sen Zhao, Wei Wei, Ding Zou, and Xianling Mao. 2022. Multi-View Intent Disentangle Graph Networks for Bundle Recommendation. In AAAI. AAAI Press, 4379–4387. This paper is under CC 4.0 license. available on arxiv

CLHE: A Breakthrough in Bundle Construction - Challenges Overcome and Paths Ahead

This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. Authors: (1) Shanshan Han & Qifan Zhang, UCI; (2) Wenxuan Wu, Texas A&M University; (3) Baturalp Buyukates, Yuhang Yao & Weizhao Jin, USC; (4) Salman Avestimehr, USC & FedML. Table of Links Abstract and Introduction Problem Setting The Proposed Two-Stages Anomaly Detection Verifiable Anomaly Detection using ZKP Evaluations Related Works Conclusion & References 7 CONCLUSION We present a cutting-edge anomaly detection technique specifically designed for the real-world FL systems. Our approach utilizes an early cross-round check that activates subsequent anomaly detection exclusively in the presence of attacks. When attacks happen, our approach removes anomaly client models efficiently, ensuring that the local models submitted by benign clients remain unaffected. Further, by leveraging ZKPs, participating clients get to verify the integrity of the anomaly detection and removal performed by the server. The practical design and the inherent efficiency of our approach make it well-suited for real-world FL systems. Our plans for future works include extending our approach to asynchronous FL and vertical FL scenarios. REFERENCES T. Aoki. On the stability of the linear transformation in banach spaces. Journal of the Mathematical Society of Japan, 2(1-2):64–66, 1950. E. Bagdasaryan, A. Veit, Y. Hua, D. Estrin, and V. Shmatikov. How to backdoor federated learning. In AISTATS, 2020a. Eugene Bagdasaryan, Andreas Veit, Yiqing Hua, Deborah Estrin, and Vitaly Shmatikov. How to backdoor federated learning. In International Conference on Artificial Intelligence and Statistics, pp. 2938–2948. PMLR, 2020b. Arjun Nitin Bhagoji, Supriyo Chakraborty, Prateek Mittal, and Seraphin Calo. Analyzing federated learning through an adversarial lens. In International Conference on Machine Learning, pp. 634– 643. PMLR, 2019. P. Blanchard, E. M. El Mhamdi, R. Guerraoui, and J. Stainer. Machine learning with adversaries: Byzantine tolerant gradient descent. In NeurIPS, 2017. David Byrd and Antigoni Polychroniadou. Differentially private secure multi-party computation for federated learning in financial applications. In Proceedings of the First ACM International Conference on AI in Finance, pp. 1–9, 2020. Sebastian Caldas, Sai Meher Karthik Duddu, Peter Wu, Tian Li, Jakub Konecnˇ y, H Brendan McMa- ` han, Virginia Smith, and Ameet Talwalkar. Leaf: A benchmark for federated settings. arXiv preprint arXiv:1812.01097, 2018. Xiaoyu Cao and Neil Zhenqiang Gong. Mpaf: Model poisoning attacks to federated learning based on fake clients. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 3396–3404, 2022. Xiaoyu Cao and Neil Zhenqiang Gong. Mpaf: Model poisoning attacks to federated learning based on fake clients. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 3396–3404, 2022. Xiaoyu Cao, Zaixi Zhang, Jinyuan Jia, and Neil Zhenqiang Gong. Flcert: Provably secure federated learning against poisoning attacks. IEEE Transactions on Information Forensics and Security, 17: 3691–3705, 2022. Mingqing Chen, Rajiv Mathews, Tom Ouyang, and Franc¸oise Beaufays. Federated learning of outof-vocabulary words. arXiv preprint arXiv:1903.10635, 2019. Y. Chen, L. Su, and J. Xu. Distributed statistical machine learning in adversarial settings: Byzantine gradient descent. ACM on Measurement and Analysis of Computing Systems, 1(2):1–25, 2017. Alexander Chowdhury, Hasan Kassem, Nicolas Padoy, Renato Umeton, and Alexandros Karargyris. A review of medical federated learning: Applications in oncology and cancer research. In Brainlesion: Glioma, Multiple Sclerosis, Stroke and Traumatic Brain Injuries: 7th International Workshop, BrainLes 2021, Held in Conjunction with MICCAI 2021, Virtual Event, September 27, 2021, Revised Selected Papers, Part I, pp. 3–24. Springer, 2022. M. Fang, X. Cao, J. Jia, and N. Gong. Local model poisoning attacks to Byzantine-robust federated learning. In USENIX Security, 2020. B. Feng, L. Qin, Z. Zhang, Y. Ding, and S. Chu. ZEN: An optimizing compiler for verifiable, zero-knowledge neural network inferences. 2021. Cryptology ePrint Archive. Grant S Fletcher. Clinical epidemiology: the essentials. Lippincott Williams & Wilkins, 2019. R. Freivalds. Probabilistic machines can use less running time. In IFIP Congress, 1977. Shuhao Fu, Chulin Xie, Bo Li, and Qifeng Chen. Attack-resistant federated learning with residualbased reweighting. arXiv preprint arXiv:1912.11464, 2019. Clement Fung, Chris JM Yoon, and Ivan Beschastnikh. The limitations of federated learning in sybil settings. In RAID, pp. 301–316, 2020. S. Goldwasser, S. Micali, and C. Rackoff. The knowledge complexity of interactive proof systems. SIAM Jour. on Comp., 18(1):186–208, 1989. J. Groth. On the size of pairing-based non-interactive arguments. In Eurocrypt, 2016. Rachid Guerraoui, Sebastien Rouault, et al. The hidden vulnerability of distributed learning in ´ byzantium. In International Conference on Machine Learning, pp. 3521–3530. PMLR, 2018. S. Han, H. Wang, J. Wan, and J. Li. An iterative scheme for leverage-based approximate aggregation. In IEEE ICDE, 2019. Shanshan Han, Baturalp Buyukates, Zijian Hu, Han Jin, Weizhao Jin, Lichao Sun, Xiaoyang Wang, Chulin Xie, Kai Zhang, Qifan Zhang, et al. Fedmlsecurity: A benchmark for attacks and defenses in federated learning and federated llms. arXiv preprint arXiv:2306.04959, 2023. Andrew Hard, Kanishka Rao, Rajiv Mathews, Swaroop Ramaswamy, Franc¸oise Beaufays, Sean Augenstein, Hubert Eichner, Chloe Kiddon, and Daniel Ramage. Federated learning for mobile ´ keyboard prediction. arXiv preprint arXiv:1811.03604, 2018. Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. L. He, S. P. Karimireddy, and M. Jaggi. Byzantine-robust decentralized learning via self-centered clipping. 2022. Available on arXiv:2202.01545. Xiao Jin, Pin-Yu Chen, Chia-Yi Hsu, Chia-Mu Yu, and Tianyi Chen. Cafe: Catastrophic data leakage in vertical federated learning. Advances in Neural Information Processing Systems, 34:994–1006, 2021. Sai Praneeth Karimireddy, Lie He, and Martin Jaggi. Byzantine-robust learning on heterogeneous datasets via bucketing. arXiv preprint arXiv:2006.09365, 2020. Sanjay Kariyappa, Chuan Guo, Kiwan Maeng, Wenjie Xiong, G. Edward Suh, Moinuddin K. Qureshi, and Hsien-Hsin S. Lee. Cocktail party attack: Breaking aggregation-based privacy in federated learning using independent component analysis. In International Conference on Machine Learning, 2022. URL https://api.semanticscholar.org/CorpusID: 252211968. Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009. Maximilian Lam, Gu-Yeon Wei, David Brooks, Vijay apa Reddi, and Michael Mitzenmacher. Gradient disaggregation: Breaking privacy in federated learning by reconstructing the user participant matrix. In International Conference on Machine Learning, pp. 5959–5968. PMLR, 2021. S. Lee, H. Ko, J. Kim, and H. Oh. vCNN: Verifiable convolutional neural network based on zksnarks. 2020. Cryptology ePrint Archive. David Leroy, Alice Coucke, Thibaut Lavril, Thibault Gisselbrecht, and Joseph Dureau. Federated learning for keyword spotting. In IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6341–6345, 2019. Suyi Li, Yong Cheng, Wei Wang, Yang Liu, and Tianjian Chen. Learning to detect malicious clients for robust federated learning. arXiv preprint arXiv:2002.00211, 2020. T. Liu, X. Xie, and Y. Zhang. ZkCNN: Zero knowledge proofs for convolutional neural network predictions and accuracy. In ACM CCS, 2021. A. Lyon. Why are normal distributions normal? The British Journal for the Philosophy of Science, 65(3):621–649, 2014. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication-efficient learning of deep networks from decentralized data. In Artificial intelligence and statistics, pp. 1273–1282. PMLR, 2017a. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication-efficient learning of deep networks from decentralized data. In Artificial intelligence and statistics, pp. 1273–1282. PMLR, 2017b. J. Osborne. Improving your data transformations: Applying the Box-Cox transformation. Practical Assessment, Research, and Evaluation, 15(1):12, 2010. Mustafa Safa Ozdayi, Murat Kantarcioglu, and Yulia R Gel. Defending against backdoors in federated learning with robust learning rate. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 35, pp. 9268–9276, 2021. Krishna Pillutla, Sham M Kakade, and Zaid Harchaoui. Robust aggregation for federated learning. IEEE Transactions on Signal Processing, 70:1142–1154, 2022. Swaroop Ramaswamy, Rajiv Mathews, Kanishka Rao, and Franc¸oise Beaufays. Federated learning for emoji prediction in a mobile keyboard. arXiv preprint arXiv:1906.04329, 2019. M. Rosenblatt. A central limit theorem and a strong mixing condition. National Academy of Sciences, 42(1):43–47, 1956. R. M. Sakia. The Box-Cox transformation technique: A review. Journal of the Royal Statistical Society: Series D, 41(2):169–178, 1992. E. B. Sasson, A. Chiesa, C. Garman, M. Green, I. Miers, E. Tromer, and M. Virza. Zerocash: Decentralized anonymous payments from bitcoin. In IEEE S&P, 2014. Jingwei Sun, Ang Li, Louis DiValentin, Amin Hassanzadeh, Yiran Chen, and Hai Li. Fl-wbc: Enhancing robustness against model poisoning attacks in federated learning from a client perspective. Advances in Neural Information Processing Systems, 34:12613–12624, 2021. Ziteng Sun, Peter Kairouz, Ananda Theertha Suresh, and H Brendan McMahan. Can you really backdoor federated learning? arXiv preprint arXiv:1911.07963, 2019. Circom Contributors. Circom zkSNARK ecosystem, 2022. https://github.com/iden3/circom. Vale Tolpegin, Stacey Truex, Mehmet Emre Gursoy, and Ling Liu. Data poisoning attacks against federated learning systems. In European Symposium on Research in Computer Security, pp. 480– 501. Springer, 2020. Richard Tomsett, Kevin Chan, and Supriyo Chakraborty. Model poisoning attacks against distributed machine learning systems. In Artificial Intelligence and Machine Learning for Multi-Domain Operations Applications, volume 11006, pp. 481–489. SPIE, 2019. H. Wang, K. Sreenivasan, S. Rajput, H. Vishwakarma, S. Agarwal, J. Sohn, K. Lee, and D. Papailiopoulos. Attack of the tails: Yes, you really can backdoor federated learning. In NeurIPS, 2020. Jianhua Wang. Pass: Parameters audit-based secure and fair federated learning scheme against free rider. arXiv preprint arXiv:2207.07292, 2022. S. Weisberg. Yeo-Johnson power transformations. 2001. Available at https://www.stat.umn.edu/arc/yjpower.pdf. Cong Xie, Oluwasanmi Koyejo, and Indranil Gupta. SLSGD: Secure and Efficient Distributed Ondevice Machine Learning. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 213–228. Springer, 2020. H. Yang, X. Zhang, M. Fang, and J. Liu. Byzantine-resilient stochastic gradient descent for distributed learning: A Lipschitz-inspired coordinate-wise median approach. In IEEE CDC, 2019. Dong Yin, Yudong Chen, Kannan Ramchandran, and Peter Bartlett. Byzantine-robust distributed learning: Towards optimal statistical rates. In International Conference on Machine Learning, pp. 5650–5659. PMLR, 2018. Zaixi Zhang, Xiaoyu Cao, Jinyuan Jia, and Neil Zhenqiang Gong. Implementation of fldetector. https://github.com/zaixizhang/FLDetector, 2022a. Zaixi Zhang, Xiaoyu Cao, Jinyuan Jia, and Neil Zhenqiang Gong. Fldetector: Defending federated learning against model poisoning attacks via detecting malicious clients. In Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, pp. 2545–2555, 2022b. Zhengming Zhang, Ashwinee Panda, Linyue Song, Yaoqing Yang, Michael W. Mahoney, Joseph Gonzalez, Kannan Ramchandran, and Prateek Mittal. Neurotoxin: Durable backdoors in federated learning. In International Conference on Machine Learning, 2022c. URL https: //api.semanticscholar.org/CorpusID:249889464. A APPENDIX A.1 PROOF OF THE RANGE OF PPV B ZKP IMPLEMENTATION B.1 CHOICE OF THE ZKP SYSTEM In our implementation, we use the Groth16 (Groth, 2016) zkSNARK scheme implemented in the Circom library (Circom Contributors, 2022) for all the computations described above. We chose this ZKP scheme because its construction ensures constant proof size (128 bytes) and constant verification time. Because of this, Groth16 is popular for blockchain application due to small on-chain computation. There are other ZKP schemes based on different construction that can achieve faster prover time (Liu et al., 2021), but the proof size is too big and verification time is not constant, which is a problem if verifier lacks computational power. The construction of a ZKP scheme that is efficient for both prover and verifier is still an open research direction. B.2 SUPPLEMENTARY EXPERIMENTS FOR IMPORTANCE LAYER

Zero-Knowledge-Proof-Based Anomaly Detection: Conclusion & References

This paper is available on arxiv under CC BY 4.0 DEED license. Authors: (1) Zhipeng Wang, Department of Computing, Imperial College London; (2) Nanqing Dong Department of Computer Science, University of Oxford; (3) Jiahao Sun, Data Science Institute, Imperial College London; (4) William Knottenbelt, Department of Computing, Imperial College London. TABLE OF LINKS Abstract & Introduction Related Work & Preliminaries Methodology Theoretical and Empirical Analysis Results Conclusion & References Conclusion We present a novel and pioneering approach called zkFL, which utilizes ZKPs to ensure a trustworthy aggregation process on the centralized aggregator. Through rigorous theoretical analysis, we establish that zkFL effectively addresses the challenge posed by a malicious aggregator during the model aggregation phase. Moreover, we extend zkFL to a blockchain-based system, significantly reducing the verification burden on the clients. The empirical analysis demonstrates that our design achieves superior levels of security and privacy compared to traditional FL systems while maintaining a favorable training speed for the clients. These results showcase the practical feasibility and potential advantages of zkFL
and its blockchain-based version in real-world applications. Acknowledgments This work was supported in part by the FLock Research Grant. References Diego F Aranha, Emil Madsen Bennedsen, Matteo Campanelli, Chaya Ganesh,
Claudio Orlandi, and Akira Takahashi. Eclipse: enhanced compiling method for
pedersen-committed zksnark engines. In IACR International Conference on PublicKey Cryptography, pages 584–614. Springer, 2022. Karim Baghery, Markulf Kohlweiss, Janno Siim, and Mikhail Volkhov. Another
look at extraction and randomization of groth’s zk-snark. In Financial Cryptography and Data Security: 25th International Conference, FC 2021, Virtual Event,
March 1–5, 2021, Revised Selected Papers, Part I 25, pages 457–475. Springer, Nir Bitansky. Verifiable random functions from non-interactive witnessindistinguishable proofs. Journal of Cryptology, 33(2):459–493, 2020. Joseph Bonneau, Andrew Miller, Jeremy Clark, Arvind Narayanan, Joshua A Kroll, and Edward W Felten. Sok: Research perspectives and challenges for bitcoin and cryptocurrencies. In 2015 IEEE Symposium on Security and Privacy, pages 104– 121. IEEE, 2015. Sean Bowe, Jack Grigg, and Daira Hopwood. Recursive proof composition without a trusted setup. Cryptology ePrint Archive, 2019. Lukas Burkhalter, Hidde Lycklama, Alexander Viand, Nicolas K¨uchler, and Anwar Hithnawi. Rofl: Attestable robustness for secure federated learning. arXiv preprint arXiv:2107.03311, 2021. Xiaoyu Cao and Neil Zhenqiang Gong. Mpaf: Model poisoning attacks to federated learning based on fake clients. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 3396–3404, 2022. Nanqing Dong, Zhipeng Wang, Jiahao Sun, Michael Kampffmeyer, Yizhe Wen, Shuoying Zhang, William Knottenbelt, and Eric Xing. Defending against malicious behaviors in federated learning with blockchain. arXiv preprint arXiv:2307.00543, 2023. Haohua Duan, Liyao Xiang, Xinbing Wang, Pengzhi Chu, and Chenghu Zhou. A new zero knowledge argument for general circuits and its application. IEEE Transactions on Information Forensics and Security, 2023. Juan Garay and Aggelos Kiayias. Sok: A consensus taxonomy in the blockchain era. In Topics in Cryptology–CT-RSA 2020: The Cryptographers’ Track at the RSA Conference 2020, San Francisco, CA, USA, February 24–28, 2020, Proceedings, pages 284–318. Springer, 2020. Oded Goldreich and Yair Oren. Definitions and properties of zero-knowledge proof systems. Journal of Cryptology, 7(1):1–32, 1994. Jens Groth. On the size of pairing-based non-interactive arguments. In International Conference on the Theory and Applications of Cryptographic Techniques, pages 305–326. Springer, 2016. Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pages 770–778, 2016. Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In CVPR, pages 4700–4708, 2017. Huawei Huang, Wei Kong, Sicong Zhou, Zibin Zheng, and Song Guo. A survey of state-of-the-art on blockchains: Theories, modelings, and tools. ACM Computing Surveys (CSUR), 54(2):1–42, 2021. Wael Issa, Nour Moustafa, Benjamin Turnbull, Nasrin Sohrabi, and Zahir Tari. Blockchain-based federated learning for securing internet of things: A comprehensive survey. ACM Computing Surveys, 55(9):1–43, 2023. Peter Kairouz, H Brendan McMahan, Brendan Avent, Aur´elien Bellet, Mehdi Bennis, Arjun Nitin Bhagoji, Kallista Bonawitz, Zachary Charles, Graham Cormode, Rachel Cummings, et al. Advances and open problems in federated learning. Foundations and Trends® in Machine Learning, 14(1–2):1–210, 2021. Joe Kilian. A note on efficient zero-knowledge proofs and arguments. In Proceedings of the twenty-fourth annual ACM symposium on Theory of computing, pages 723– 732, 1992. Hyesung Kim, Jihong Park, Mehdi Bennis, and Seong-Lyun Kim. Blockchained ondevice federated learning. IEEE Communications Letters, 24(6):1279–1283, 2019. Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015. Yijing Li, Xiaofeng Tao, Xuefei Zhang, Junjie Liu, and Jin Xu. Privacy-preserved federated learning for autonomous driving. IEEE Transactions on Intelligent Transportation Systems, 23(7):8423–8434, 2021. Tianyi Liu, Xiang Xie, and Yupeng Zhang. Zkcnn: Zero knowledge proofs for convolutional neural network predictions and accuracy. In ACM SIGSAC Conference on Computer and Communications Security, pages 2968–2985, 2021. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication-efficient learning of deep networks from decentralized data. In AISTATS, pages 1273–1282. PMLR, 2017. Silvio Micali, Michael Rabin, and Salil Vadhan. Verifiable random functions. In 40th annual symposium on foundations of computer science (cat. No. 99CB37039), pages 120–130. IEEE, 1999. Satoshi Nakamoto. Bitcoin: A peer-to-peer electronic cash system. Decentralized business review, 2008. Torben Pryds Pedersen. Non-interactive and information-theoretic secure verifiable secret sharing. In Annual international cryptology conference, pages 129–140. Springer, 1991. Youyang Qu, Md Palash Uddin, Chenquan Gan, Yong Xiang, Longxiang Gao, and John Yearwood. Blockchain-enabled federated learning: A survey. ACM Computing Surveys, 55(4):1–35, 2022. Eli Ben Sasson, Alessandro Chiesa, Christina Garman, Matthew Green, Ian Miers, Eran Tromer, and Madars Virza. Zerocash: Decentralized anonymous payments from bitcoin. In 2014 IEEE Symposium on Security and Privacy, pages 459–474. IEEE, 2014. Xiaoqiang Sun, F Richard Yu, Peng Zhang, Zhiwei Sun, Weixin Xie, and Xiang Peng. A survey on zero-knowledge proof in blockchain. IEEE network, 35(4):198– 205, 2021. Zhipeng Wang, Stefanos Chaliasos, Kaihua Qin, Liyi Zhou, Lifeng Gao, Pascal Berrang, Benjamin Livshits, and Arthur Gervais. On how zero-knowledge proof blockchain mixers improve, and worsen user privacy. In Proceedings of the ACM Web Conference 2023, pages 2022–2032, 2023. Jiasi Weng, Jian Weng, Gui Tang, Anjia Yang, Ming Li, and Jia-Nan Liu. pvcnn: Privacy-preserving and verifiable convolutional neural network testing. IEEE Transactions on Information Forensics and Security, 18:2218–2233, 2023. Jiasi Weng, Jian Weng, Jilian Zhang, Ming Li, Yue Zhang, and Weiqi Luo. Deepchain: Auditable and privacy-preserving deep learning with blockchain-based incentive. IEEE Transactions on Dependable and Secure Computing, 18(5):2438– 2455, 2019. Gavin Wood. Ethereum: A secure decentralised generalised transaction ledger. Ethereum project yellow paper, 151:1–32, 2014. Juncen Zhu, Jiannong Cao, Divya Saxena, Shan Jiang, and Houda Ferradi. Blockchain-empowered federated learning: Challenges, solutions, and future directions. ACM Computing Surveys, 55(11):1–31, 2023.

Zero Knowledge Proof based Gradient Aggregation for Federated Learning: Conclusion & References

The quantity and diversity of data are important factors in the effectiveness of most machine learning models. The amount and diversity of data supplied during training heavily influence the prediction accuracy of these models. Hidden neurons are common in deep learning models that have been trained to perform well on complex tasks. The number of trainable parameters grows in unison with the number of hidden neurons. The amount of data needed is proportional to the number of learnable parameters in the model. Applying a range of transformations to the available data to synthesize new data is one technique to cope with the challenge of limited data. 'Data Augmentation' refers to the process of synthesizing new data from existing data. Data augmentation can be utilized to address both requirements; the amount of data and the diversity of the training data needed to create an accurate machine learning model. What is Data Augmentation is a set of techniques used to increase the amount of data in a machine learning model by adding slightly modified copies of already existing data or newly created synthetic data from existing data. It helps smooth out the machine learning model and reduce the of data. Data augmentation overfitting Techniques Images are modified slightly and then added to the data sets used in machine learning models. Some techniques used to augment images for machine learning algorithm datasets are: Geometric transformations Elastic transformations Flipping Color modification Cropping Rotation Translation (moving the image in the x or y direction) Noise injection Zoom and scaling Random erasing The original image of a Quoka on the left, with various augmented versions of the image on the right. Source: http://ai.stanford.edu/ Benefits of Data Augmentation A machine learning model performs better and is more accurate when the dataset is rich and comprehensive. By creating fresh and varied instances to train datasets, data augmentation can help improve the performance and results of machine learning models. Data collection and labeling can be time-consuming and costly for machine learning models. Companies can lower these operational costs by transforming datasets using data augmentation techniques. Cleaning data is one of the phases required in creating a data model with a high accuracy level. However, if data cleaning reduces representability, the model will not make accurate predictions for real-world inputs. Machine learning models can be made more robust via data augmentation approaches, which create several variances that the model might encounter in the actual world. Use Case: Medical Imaging A major use case for data augmentation at the moment is medical imaging. The datasets for medical images aren’t very big, and because of regulations and privacy issues, sharing data isn’t easy. Furthermore, in the event of rare diseases, the data sets are even more limited. Medical imaging firms are using data augmentation to add diversity to their data sets. Conclusion Businesses can use data augmentation to lessen their reliance on training data preparation and develop more accurate machine learning models faster. Data augmentation can also help machine learning models with lots of data already by increasing the amount of relevant data in the dataset. Also published here . I am helping clients identify and invest in Emerging Technologies early on so that they can innovate and grow exponentially. Follow Lansaar Research for the latest in emerging technologies and new business models.

A Gentle Introduction to Data Augmentation

There has been an exponential rise in applications of AI, Data Science, and Machine Learning spanning across a wide variety of industries. Scientists, researchers, and data scientists have become increasingly aware of . This is in response to the range of individual and societal harms and the negative consequences that AI systems may cause. AI Ethics AI ethics is a set of values, principles, and techniques that employ widely accepted standards of right and wrong to guide moral conduct in the development and use of AI technologies. In , any given algorithm is said to be , or to have , if its results are independent of given variables, especially those considered sensitive. The traits of individuals should not correlate with the outcome (i.e. gender, ethnicity, sexual orientation, disability, etc.). machine learning and AI fair fairness Most of the ML algorithms, which are unfair, suffer from disparate treatment if it's decisions are (partly) based on the subject’s sensitive attribute. A disparate impact occurs if outcomes disproportionately hurt (or benefit) people with certain sensitive attribute values (e.g., females, blacks). Fairness is based on the following. Unawareness Demographic Parity Equalized Odds Predictive Rate Parity Individual Fairness Counterfactual fairness The research about Fair ML Algorithms and ToolKits shows that it can detect and mitigate bias and yield fair outcomes for both text and visual data. The algorithms that have been developed and they fall into three phases of ML lifecycle: and preprocessing optimization at training time, and post-processing in-algorithmic optimization. In this blog, we primarily discuss the that can help us to design Fair AI solutions. open-source toolkits and algorithms ToolKits What-If-Tool — By Google launched by Google is a new feature of the open-source TensorBoard web application. This tool enables: What-If-Tool Users to an ML model without writing code. analyze With given pointers to the TensorFlow model and a dataset, the – offers an interactive visual interface for exploring model results. What If Tool It also allows of examples from your dataset and see the effect of those changes. manual editing It supports automatic generation of which show how the model’s predictions change as any single feature is changed. partial dependence plots AI Fairness 360 — By IBM The AI Fairness 360 toolkit is an extensible open-source library containing techniques developed by the IBM research community to help and throughout the AI application lifecycle. AI Fairness 360 package is available in both Python and R. detect,  mitigate bias in machine learning models The includes AI Fairness 360 package A for datasets and models to test for biases comprehensive set of metrics for these metrics, and Algorithms to bias in datasets and models. Explanations mitigate Designed to algorithmic research from the lab into the actual practice of domains as wide-ranging as finance, human capital management, healthcare, and education. translate The below figure illustrates different fairness metrics on protected attributes sex and age on German Credit Dataset. Source This link states in detail more on the bias mitigation algorithms (optimized pre-processing, disparate parity remover) and Supported Fairness Metrics. Github Fair-Learn — By Microsoft This tool primarily developed by Microsoft focuses on how an AI system is behaving unfairly in terms of its impact on people – i.e. in terms of harms. It includes: – These harms can occur when AI systems extend or withheld opportunities, resources, or information. Some of the key applications are in hiring, school admissions, and lending. Allocation harms Quality of service refers to whether a system works as well for one person as it does for another, even if no opportunities, resources, or information are extended or withheld. Quality-of-service harms – Source This describes how the tool incorporates different types of fairness algorithms (reduction variants, post-processing algorithms) that can be applied to Classification and Regression problems. blog To integrate the Fairness tool, refer to https://github.com/fairlearn/fairlearn Themis-ml A Python utility built on top of and that implements fairness-aware machine learning algorithms, by measuring and The objective behind using this tool is to use discrimination-aware techniques to use it as a preference (bias) for or against a set of social groups that result in the unfair treatment of its members with respect to some outcome. themis-ml pandas sklearn discrimination mitigating discrimination. With ML algorithms, try this out with pre-processing library, model estimation, and post-processing techniques on different datasets available from Github The Bias and Fairness Audit Toolkit is an open-source bias audit toolkit for data scientists, machine learning researchers, and policymakers to audit machine learning models for and , and to make informed and equitable decisions around developing and deploying predictive tools. Aequitas discrimination bias Toolkit for Auditing and Mitigating Bias and Fairness of Machine Learning Systems is developed for and primarily for bias and fairness of machine learning systems, in addition to mitigating bias and adjust fairness through , with special emphasis on NLP models. Responsibly practitioners researchers auditing algorithmic interventions Derivable Conditional Fairness Regularizer is an method to deal with fairness issues in supervised machine learning tasks. Traditional fairness notations, such as and are demonstrated as special cases of conditional fairness. The main objective of this library is to define , which can be integrated into any decision-making model, to track the trade-off between and of algorithmic decision making and to measure the degree of in . DCFR adversarial learning demographic parity equalized odds Derivable Conditional Fairness Regularizer (DCFR) precision fairness unfairness adversarial representation Fairness Comparison This repository is meant to facilitate the of f , by accounting for differences in different fairness techniques. The benchmarking technique helps to compare a number of different algorithms under a variety of fairness measures, and a large number of existing datasets. This benchmarking tool also simulates that tend to be to fluctuations in dataset composition. benchmarking airness aware machine learning algorithms fairness-preserving algorithms sensitive Counterfactual Local Explanations via Regression (CLEAR) Though not a Fairness tool, the model tool explains single predictions of machine learning classifiers, based on the view that a satisfactory explanation of a single prediction needs to both explain the value of that prediction and answer questions. This explainable tool tries to answer impact of different questions by considering the relative importance of the input features and show how they interact. Explainability CLEAR ’what-if-things-had-been-different’ Differential Fairness This library leverages the connections between and , and further measures the fairness cost of with a parameter The concept has originated from the Differential Privacy to limit/restrict a combination of and , marginalizing over the remaining attributes of the dataset x, with a probability of 80%. differential privacy legal notions of fairness mechanism M(x) ε. protected group’s intersecting gender, race, nationality Flexible-Fairness-Constraints This library introduces an framework to enforce fairness constraints on . It uses a composition technique that can flexibly accommodate different combinations of fairness constraints during inference. adversarial graph embeddings In the context of , this framework also allows one user to request, such that their recommendations are invariant to both their age and gender. Further, this library also allows other users to request invariance to just their age, which is demonstrated with standard and recommender system benchmarks. social recommendations knowledge graph FairRegression This library optimizes the accuracy of the estimation subject to a of (when the subject is composed of multiple sensitive attributes e.g., race, gender, age). The fairness constraint induces a nonconvexity of the feasible region, which disables the use of an off-the-shelf convex optimizer. user-defined level fairness Fair Classification This library is composed of implementation techniques in python for the fair classification mechanisms introduced in AISTATS’17, WWW’17, and papers. logistic regression NIPS’17 Fair Clustering Below are some of the techniques involved in designing Fair Clustering Algorithms: Scalable Fair Clustering This library implements a fair clustering algorithm. It computes a of the dataset, followed by a non-fair k-median algorithm on the centers. The resulting clustering is then extended to the whole dataset by assigning each data point to the cluster that contains its , to yield a final fair clustering. k-median fairlet decomposition fairlet fairlet center Fair Algorithms for Clustering Variational Fair Clustering This library implements a clustering method that finds clusters with specified of different demographic groups pertaining to a sensitive attribute of the dataset (e.g. race, gender, etc.). It can be used for any well-known clustering method such as , etc. in a flexible and way. proportions K-means, K-median, or Spectral clustering (Normalized cut) scalable Proportionally Fair Clustering This library implements in a metric context, by clustering n points with k centers. Fairness is defined as the proportionality to mean that any are entitled to form their own cluster if there is another center that is closer in distance for all n/k points. proportional centroid clustering n/k points Fair Clustering Through Fairlets This library introduces the concept of fairlets, which are minimal sets that satisfy while the clustering objective. In its implementation, it shows that any fair clustering problem can be decomposed into first finding good fairlets, and then using existing machinery for traditional clustering algorithms. fair representation approximately preserving Though finding good fairlets can be NP-hard, the library strives to obtain efficient algorithms based on . approximation minimum cost flow Fair Recommendation Systems Below are some of the techniques involved in designing Fair Recommendation Systems: Two-Sided Fairness for Personalized Recommendations in Two-Sided Platforms The objective of this fair recommendation library is in the context of , comprising on one side and . Recommendation services in these platforms have been built primarily to maximize customer satisfaction through preferences of the individual customers. two-sided online platforms customers producers personalized This library incorporates a fair allocation of goods by guaranteeing at least for most of the and for every indivisible Maximin Share (MMS) of exposure producers Envy-Free up to One item (EF1) fairness customer. FLAG: Frequency Linked Attribute for Evaluating Consumer-side Fairness The goal of this library is to demonstrate an application of assigning to different recommendation data sets. Such attributes are personally sensitive and excluded from data sets. synthetic demographic attributes publicly-available fairness-aware variational autoencoder for collaborative filtering is a framework for making recommendations. The objective of this library is to incorporate randomness in the regular operation of in order to increase the fairness (mitigate the position bias) in multiple rounds of recommendation Variational auto-encoders VAEs Fairness-Aware_Tensor-Based_Recommendation The objective of this library is to enhance recommendation fairness while preserving recommendation quality. It achieves this goal by introducing (i) a new for isolating sensitive features sensitive latent factor matrix (ii) a that extracts sensitive information that can taint other factors sensitive information regularizer latent (iii) an effective algorithm to solve the proposed optimization model (iv) extension to cases. multi-feature and multi-category SIREN is a python interface built to offer in based on the toolbox and visualizations for two diversity metrics (long-tail and unexpectedness). SIREN can be used by content providers (news outlets) to investigate which better according to their diverse needs, in addition to analyzing recommendation effects in a different news environment. Siren diversity recommendations MyMediaLite recommendation strategy fits Awesome AI Guidelines There has been a large amount of content published which attempts to address these issues through ” and beyond, which are captured through this repository . In addition, there are papers, documents, and resources available at for introducing Fairness in “Principles”, “Ethics Frameworks”, “Standards & Regulations”, “Checklists link Github Computer Vision. Fairness in Machine Learning This library contains implementation of and Pytorch implementation of . The principle behind this library is to introduce a training procedure based on adversarial networks for enforcing the property (or, equivalently, with respect to attributes) on a predictive model. Further, it also includes a to make a between accuracy and robustness Keras & TensorFlow Towards fairness in ML with adversarial networks Fairness in Machine Learning with PyTorch pivotal fairness continuous hyperparameter trade-off FairPut — Fair Machine Learning Framework is a light open framework that strives to state a process at the end of the machine learning pipeline to enhance model fairness. It also plays a simultaneously role in enhancing model and a reasonable level of . FairPut preferred interpretability, robustness, accuracy Other Libraries — EthicML is a library for the researcher’s toolkit for performing and assessing . It has support for multiple sensitive attributes, vision datasets, codebase typed with mypy, tested code and reproducible results. EthicML algorithmic fairness – This library introduces in , where regardless of the contribution all individual participants can receive the same or similar models. This is achieved by utilizing reputation to enforce participants to converge to different models, which helps in achieving fairness without sacrificing the . Collaborative Fairness in Federated Learning Collaborative Fairness Federated Learning predictive performance Rich Subgroup Fairness Classification constraints on small collections of appear to be fair on each group, but badly violates the fairness constraint on one or more defined over the protected attributes, (from Kearns et al., ) pre-defined groups individual structured subgroups https://arxiv.org/abs/1711.05144 This fairness library implements statistical notions of fairness across (or infinitely) many , defined by a structured class of functions over the protected attributes. This library works primarily with sklearn binary classifiers ( ) and group classes having . The library provides: exponentially subgroups LinearRegression Linear threshold functions subject to subgroup fairness constraints ( ) Learning fair classifiers https://arxiv.org/abs/1711.05144 classifier predictions for fairness violations Auditing tradeoffs between error and fairness metrics fairness sensitive datasets for experiments ( ) Visualizing https://arxiv.org/abs/1808.08166 It also supports supported for learning and auditing: Fairness metrics False Positive Rate Equality False Negative Rate Equality Fairness in Sentiment Prediction demonstrates how to use SenSR to gender and racial biases in the task described. This fairness distance is computed on the basis of and can be tried out from this link on . Sensitive Subspace Robustness (SenSR) eliminate sentiment prediction Truncated SVD Github – Contains notebooks to train deep learning models as a part of the project. UnIntended Bias Analysis Conversational AI Conversational AI References https://people.engr.tamu.edu/caverlee/pubs/zhu2018fairness.pdf https://dl.acm.org/doi/10.1145/3297662.3365798 https://arxiv.org/abs/1802.04422 https://arxiv.org/abs/2006.10483 http://jfoulds.informationsystems.umbc.edu/papers/2019/Foulds%20(2019)%20-%20DifferentialFairness_NeurIPS_MLWG.pdf https://arxiv.org/abs/1902.03519 https://paperswithcode.com/paper/fair-clustering-through-fairlets Fair K-MEans using Matlab: https://github.com/fairkmeans/Fair-K-Means-Clustering https://papers.nips.cc/paper/2017/file/978fce5bcc4eccc88ad48ce3914124a2-Paper.pdf https://arxiv.org/abs/1905.10674 https://towardsdatascience.com/a-tutorial-on-fairness-in-machine-learning-3ff8ba1040cb https://github.com/topics/fairness-awareness-model https://arxiv.org/abs/1711.05144 https://ai.googleblog.com/2018/09/the-what-if-tool-code-free-probing-of.html https://github.com/sharmi1206/fairness-tensorflow-toxicity-classification Previously published at https://techairesearch.com/most-essential-python-fairness-libraries-every-data-scientist-should-know/

The Ethical AI Libraries that are Critical for Every Data Scientist to Know

A new copyright-focused initiative has got underway in the Senate Judiciary Subcommittee on Intellectual Property. Its goal is to evaluate the 22-year-old Digital Millennium Copyright Act with a view to modernizing the legislation to better deal with today's Internet following the dramatic changes of the last two decades. When the Digital Millennium Copyright Act (DMCA) was introduced in 1998, few people could of imagined the online developments of the next two decades. Nevertheless, the law remains in place today and at times, according to some, struggles to keep up with whatever technology throws at it. The DMCA is a complex beast but some of its key goals are to outlaw the production and distribution of tools and services designed to circumvent DRM systems controlling access to copyright works (Section 1201 anti-circumvention) and limit the liability of online service providers for the actions of their users (Section 512). Particularly in respect of the latter, many copyright holders believe that changes are long overdue. With the U.S. Copyright Office already conducting its own study into the DMCA, Senator Thom Tillis has launched a new initiative in the Senate Judiciary Subcommittee on Intellectual Property to find ways to modernize the DMCA to better tackle the drastic changes of the past 22 years. Supported by written testimony from a number of copyright experts, the first hearing took place yesterday. Even at this early stage, it seems clear that while Section 1201 isn’t considered perfect and has its detractors, it is Section 512 that will likely prove the most controversial to address, particularly in respect of notice-and-takedown and related service provider safe harbor provisions. In his testimony, , who helped to draft the DMCA more than two decades ago, provided his assessment of why the law no longer works as intended. Steven J. Metalitz Metalitz references three ‘V’s as major issues faced by rightsholders today – the volume of infringement; the velocity of infringing activity; and the importance of voluntary arrangements, including licensing and technological collaboration. “Section 512 in general, and the notice-and-takedown system in particular, implicitly assume a model in which the volume of infringing activity is sufficiently low that human decision making can feasibly be applied on virtually a case-by case basis to decisions about whether to file a notice of infringement, how such notices are to be processed, and what action should be taken in response to them,” Metalitz testified. “If that model was ever a realistic approach, the huge volume of online infringement soon outstripped it. It was not long before the entire notice-and-takedown process became fully automated on both sides: robots talking to robots to decide the fate of particular disputed postings or links, which themselves had been generated through automated processes.” Addressing the current velocity of online infringements, Metalitz said the question of how quickly a service provider must act to deal with an infringement complaint to maintain safe harbor is now an issue. Drafters of the DMCA may not have envisioned a situation where infringing content is not only made instantly available to an audience of millions, but can instantly reappear even following a successful takedown notice, rendering the system pointless, Metalitz said. “In reviewing section 512, the subcommittee should consider what changes are needed to respond to this vast acceleration in the velocity of online infringement, as well as the ease with which Internet users with even limited tech savvy can carry it out,” he added. To help address some of these issues, Metalitz hopes that the subcommittee will look at the role of voluntary arrangements between copyright holders and service providers, such as licensing and other mechanisms, that can help to mitigate and manage online infringement, perhaps underpinned by changes in the law. Given her position as Director of Copyright Research and Policy at the Center For Protection of Intellectual Property, the testimony of demonstrated a clear determination towards a tightening of the law, with suggestions on the notice-and-takedown/service provider front proving of particular interest. Sandra Aistars “I do not advocate doing away with the protections safe harbors have afforded internet companies, because along with the negative, they have also done much to spur positive developments and creativity on the internet. Nevertheless, I believe that the last twenty two years of applying the DMCA to everyday practice have demonstrated that the marketplace and the courts have eroded the original intent of Congress,” Aistars testified. “In considering legislation, it will be important to focus on how best to restore those elements of the DMCA intended to foster cooperation between stakeholders. One clear area of legislative reform would be to restore/clarify the original meaning of red flag knowledge. “Similarly, elements of the DMCA which have received little or no attention — such as the concept of sending notice of infringements by means of representative lists, rather than link by link, and the requirement to accommodate standard technical measures, should be revisited and incorporated more effectively into any new legislation,” she added. That brings Aistars to the conclusion that notice-and-takedown is for the past and something more permanent should be considered for the future. Legislation that provides incentives for service providers to develop technologies or policies to achieve notice-and-staydown regimes would be favorable, she argued, especially since Europe is moving towards that with of the Copyright Directive. Article 17 “Some progress has already been made on this in the European Union Digital Single Market Directive, demonstrating not only that this is an achievable goal, but that internet services operating in the EU will already be required to meet such standards,” Aistars added. But while Aistars suggests that the DMCA needs significant work to be effective in today’s environment, others believe that it is still delivering on its goal to encourage innovation. Any significant change, perhaps in line with the EU’s plans, could hinder that, some suggest. Professor Rebecca Tushnet of the Harvard Law School works with the , a user-generated content project with a budget of less than $400,000 per year. It receives 1.12 billion page views per month yet receives less than one DMCA notice per month, most of them invalid. Organization for Transformative Works “Empirical research reveals that most of the internet service providers who rely on §512 are like us: receiving relatively low levels of notices and handling them individually. There just aren’t that many entities receiving millions of notices,” her testimony reads. “While market pressures and business decisions have led a few large sites like YouTube to more filter-based systems, it is important not to treat YouTube as a model for the internet at large—unless the only online service we want to survive is YouTube.” Tushnet believes that most beneficiaries of Section 512 are not companies like Google or Facebook. Indeed, if Congress targets these kinds of entities with changes to copyright law, it will only help them dominate the market. “If Congress changes the DMCA to target Google and Facebook, or because of rogue overseas sites that already aren’t complying with the DMCA to begin with, it will ensure that only Facebook, Google and pirate sites survive, making the problem of market concentration even worse without protecting creators,” Tushnet said. “Most service providers don’t need and can’t get expensive filtering technology. A mandate for that, whether called ‘staydown’ or something else, would destroy the small and medium entities that are vital to innovation, creativity, and competition on the internet.” Finally and perhaps unsurprisingly, the thorny issue of dealing with so-called ‘repeat infringers’ is set for hot debate, embedded as it is with Section 512, safe harbor, and its potential effect on regular Internet users. It is certainly on Sandra Aistars’ agenda, up to and including taking the most aggressive measures possible against those accused of infringing copyright via their home connections. Referencing the recent , which dealt with the repeat infringements of BitTorrent users and the failure of the ISP to disconnect them, Aistars expressed disappointment at those who submitted amicus briefs arguing that disconnection would be unfavorable if multiple users in a household had access to an Internet connection. BMG v Cox case “Apparently these parties believe high speed internet service is more of a basic human necessity than housing or transportation, which can both be seized under federal forfeiture laws regardless if jointly held,” Aistars testimony reads. “While I do not suggest that the circumstances under which federal forfeiture is permitted are exactly comparable, surely if the seizure of a jointly owned home or automobile is permissible, disabling internet service must also be under appropriate circumstances. Clearly ISPs have no qualms disabling service for nonpayment, for instance.” Yesterday’s hearing was just the beginning but for those who want all of the details thus far, the testimonies are available . here Originally published as “ US Congress Starts Review on Possible Modernization of the DMCA ” with the Attribution-NonCommercial 3.0 Unported (CC BY-NC 3.0) license

US Congress Starts on New Copyright-Focused Initiative

It’s closing in on a year since my last deep dive which I gave on . EOS back in July of 2017 A lot has changed in the cryptocurrency and landscape since then, and so I decided to embark on series of giving deep dives to a number of innovative blockchain projects. blockchain As a moderator for Reddit’s (which can receive as many as 10M unique monthly visitors) I do a pretty good job at being up-to-date on the latest crypto launches. /r/Cryptocurrency However, today I’ll be doing a review of a coin that I completely overlooked until it had broken the Top 50 coins by marketcap. Summary: Internet of Services Token IOST ERC-20 Token 21 Billion as of April 8th. , , , , , Token Name: Symbol: Type: Total Supply: MarketCap: $266M Social Media: Reddit Discord BitcoinTalk Twitter Medium Whitepaper: IOST Primer Technical White Paper What is IOSToken? The is a project out of China that is aims to address the fundamental scalability challenges faced by blockchain technology in order to empower people, services and machines to scale robust services on a network with a thouroughput of more than 100,000 TPS (transactions-per-second). “Internet-of-Services” (IOS) blockchain The blockchain has built in features for: Smart contract language (dApps). Private transactions. Decentralized P2P hosting (Amazon S3 competitor). User reputation tracking for decentralized marketplaces. Light weight infrastructure to run on smart devices. Rewards for ‘good-citizens’ in the blockchain. What does that mean? Well, first of all, current blockchain’s have a problem — a big problem. They can’t yet handle transactions at scale. It doesn’t matter if you are: Sending payments. Interacting with a Smart Contract or dApp. Validating an identity. Hosting a decentralized vote. All these actions require the blockchain to ‘validate’ and process the transaction. To put it into perspective, people like to compare blockchain tps against the Visa Network which handles around 2000 tps on average. While the Visa network seldom handles more than 4000 tps, the network is estimated to be able to handle around 56,000 tps. The problem with this comparison is two-fold: Payments are just one type of transaction that takes place on modern smart-blockchains. Visa as a centralized service, doesn’t cross-validate transactions with multiple nodes. This means that for them one transaction is only ever one transaction. Where as in a blockchain, one transaction could take the equivalent processing power of thousands of centralized transactions. So, how far off are we? To put this question into perspective based on the IOST blockchain and what they hope to achieve, we’ve got to look at another ‘smart blockchain’ — that is to say we have to look at a blockchain that allows the processing of programmable contracts and code execution, rather than just looking at a blockchain that only facilitates transfers or payments. **Comparison #1 — Ethereum:**Ethereum is the current king when it comes to being a robust smart contract platform and having live useable dApp products. On January 4th, 2018, a few months after rendered the Ethereum network practically unusable for nearly 24-hours, Ethereum had it’s highest transaction day of all time processing 1.35M transactions in a single day. the chaos of the CryptoKitties Craze Broken out evenly across the day, this would account to roughly 15 TPS. During this time, processing at 15 TPS, transfers become very slow and Ethereum’s “gas price” skyrocketed costing users significant fees for using the network. **Comparison #2 — Stellar:**Stellar is a blockchain managed by the non-profit Stellar foundation and partnered with companies like IBM and Square. Stellar is what is called a “decentralized permissioned blockchain” meaning that through use of its quorum slices, validators, and trusted nodes, their “Stellar Consensus Protocol” (SCP) isn’t quite as decentralized as other blockchains, but it gives them advantages in speed and cost. Recently, a team at Barclay’s testing the Stellar protocol on Google Cloud infrastructure was able to stress test a private version of the Stellar network and achieve a transaction rate of 10,000 TPS. But, it is important to note that this was in a perfectly controlled lab environment and not on the public blockchain. So how will IOST solve all this? How does IOST aim to scale up to over 100,000 TPS when current infrastructure is struggling to process that volume on a daily basis? #1 — Light Weight Nodes/IoT nodes: One of the first big wins for IOST is that not all nodes are created equal. To be a node in the or Ethereum network you at the very least need to use a dedicated computer to store the blockchain and validate transactions through mining — in many cases, you may even need a dedicated server to handle this. Bitcoin For IOST, there will be “ ” that have full functionality, and “ ” as a method of simply verifying a transaction. First Class Nodes Simplified Payment Verification Nodes (SPV) It’s the goal of IOST to target a lightweight enough node system that any smart connected device from computers, to drones, to unmanned terminals can be a node in order to verify and act on transactions. #2 — User Reputation and Community Rewards: One of the biggest challenges of distributed ledger technology outside of scale, is what is known as the ‘bad actor challenge.’ A bad actor is anyone who harms the collective technology for their own benefit. For example, on the Ethereum network we’re usually bad actors when we send small transactions (such as actions in CryptoKitties) to the network. We know they are low priority, low fee transactions that ultimately clog up the network, but we want to take our next game action so we do it anyway. In IOST, users can be rewarded in one of two ways: The “Fair and Transparent Feedback System” (FTFS). The Servi token. In the FTFS system, users, services and contracts can receive feedback based on their actions and interactions with others. Having good feedback will effect their “believability score” (which we’ll outline below) which ultimately leads to benefits within the blockchain and encourages users to act in the best interest of the community even when they are pseudo-anonymous. The Servi token on the other hand is a rewardable token that will be distributed when users take voluntary actions to help the network. This could include providing a pro-bono community service, reviewing third-party services, or making other contributions to the community. These Servi tokens are a non-tradable, self-destructing asset that contribute to a users ‘believability score’ on a one-time (per transaction) basis. **#3 — Proof-of-Believability/Believability Score:**Most networks have nodes where there is a pay-for-authority kind of loophole. In mining PoW networks, you can buy equipment to up your hashrate. With masternodes and PoS networks, you lock up capital in dedicated nodes to become the validator. IOST aims at building a faster and fairer system through what they call “Proof-of-Believability.” Proof-of-Believability acts as a hybrid to the classic Proof-of-Stake model. In Proof-of-Believability each node will have a “believability score” based on: The amount of IOST in the node. The number of earned Servi tokens. The number of positive reviews of the node. The previous actions/transactions of the node. The IOST network will randomly, and algorithmically select a set number of validators for each block. The nodes with a higher believability score in the network are by design more likely to be selected, but it is never guaranteed. Rather than strictly setting validation to a set group of trusted servers or masternodes, the PoB system is constantly selecting a random group of validators based on the reputation of good actors within the ecosystem. Since users cannot guarantee that they will be the validator on any future block, it reduces the risk of malicious action, as you would need >51% of the randomly selected actors to be bad actors with the same goal to compromise the network and this is almost impossible in a crowdsourced reputation environment where you are more often picking the ‘good actors.’ **#4 — Efficient Distributed Sharding (EDS):**Another feather in the cap of IOST is their proposal of the Efficient Distributed Sharding or “EDS” system. This allows them to split the workload across nodes, and monitor the workload on nodes as well as the general network health. When a node is overworked the EDS system selects another node to allocate some of the incoming workload to allowing a linear scaling of network capability as new nodes enter the ecosystem. #5 — Atomix: The IOST Atomix system, is an atomic commitment system designed to prevent issues such as “double-spend attacks.” When a network can have multiple transactions taking place we run into an issue where we could have two transactions that impact each other: : “ ” Transaction A Transfer 100 IOST from address X to address Y “ ” Transaction B: Check the balance of address X If we have these transactions take place within the network at the exact same time, we’re going to run into issue. For example, if the goal of “Transaction B” is to check that a user has a certain balance before proceeding with a transfer, and it checks just before or during “Transaction A” takes place then we will be generating a false-positive response for “Transaction B.” In order to deal with this, we need to handle the events as “an atomic unit” that are dealt with as a whole, and where the results of each transaction must be completed without error for any transaction to proceed. If we take this problem in the other direction, we could have a very complicated transaction with 17 different steps, and our Efficient Distributed Sharing (EDS) system decides to split each of those steps across 17 different nodes. If one of those steps has a conflict and fails, but the other 16 were able to process successfully, this would have unexpected, and possibly damaging impacts to the network. To deal with this problem, IOST is bundling the transaction steps as an atomic unit, even when it is spread across different processing entities. This ensures that the entire process either successfully commits, or entirely fails as a full atomic unit, and that no partial transactions take place. #6 — Micro State Blocks: The last key feature of IOST’s scalability is the one that, I unfortunately have the least technological understanding of, and yet, ironically am most excited for. IOST has proposed a concept called “Micro State Blocks.” One of the challenges traditional blockchains face is that they store a new ‘block’ of data every few seconds. This block is to record what happened in the blockchain in those few seconds, such as any transactions. Even if nothing took place during that time, the block still has to be issued. There is no NULL in the blockchain, there is no skipping blocks. If nothing happened you’re still storing an ‘empty block’ but it is often the same size, or nearly the same size as a block that stores transactions. Over time this blockchain gets larger and larger, but still needs to be stored on the node in order to validate transactions. This gets to be a significant problem over time. For example, right now, in April 8th 2018, the Bitcoin blockchain is roughly 165 GB in size. That means if you want to run a node, you need to download and store 165 GB worth of information. Who is behind IOST? One of the most compelling aspects of IOST is the quality of their team. While many projects rely on individual developers, the IOST Foundation has a team of more than 18 highly experienced core developers, including: Terrance Wang: Masters of Science in Distributed Systems from Princeton University Bachelors of Science in Distributed Systems from the University of Chicago. Developer of CoinLang (Princeton) high level functional language for Bitcoin Developed CoinJoin anonymity security protocol for Bitcoin Co-Founder of IOST Jimmy Zhong: Bachelors of Computer Science and Mathematics from Emory University (Magna Cum Laude) 500-Startups Alum Founder of multiple VC backed startups. Early BTC/ETH miner. Co-Founder of IOST. Kelvin Tan: Bachelors of Computer Science from Tsinghua Unviersity. Gold medal — National Olympiad in Infomatics 2008. Gold Medal of ACM Programming Contest 2011. CTO of EtherCap. Co-Founder of IOST. Sheldon Mei: Ph.D. from the University of Wisconsin-Madison Gold Medal — National Olmpiad in Infomatics. Golden Medal ACM/IPC Regionals Papers published on ICML, AAAI, WSDM and AISTATS. Chung Teng: Ph.D. Computer Security from Cornell University. Former Google Engineer. Linux Kernel Contributor. Early Blockchain Community Contributor since 2011. Bosch Lee: Bachelors of Computer Science and Applied Mathematics from Tufts University (Summa Cum Laude) Former Associate at Goldman Sachs. Former Analyst at Morgan Stanley. Former Analyst at Deloitte. Co-Founder of IOST Will Zhao: Ph.D. and M.A in Economics from Princeton University. Professor at the University of Hong Kong. Charlotte Elizabeth Protector Fellowship. Recipient of the Ronald Hsia Prize in Economics. How was the token distributed? The token was distributed in a private token sale which sold 40% of the total 21 billion IOST to private fund investors. The IOST Foundation also announced that they were locking up all 7.35 billion of their IOST tokens from the foundation allocation until the launch of their mainnet. So, the mainnet isn’t launched yet? What’s the deal? No, the mainnet isn’t launched yet. IOST recently published the first of their code to — building a new blockchain on an entirely new consensus protocol is something that takes time. But, IOST has been moving at an aggressive pace. their public Github Based on their roadmap they hope to deploy a fulling functioning testnet by Q2 of 2018, and launch a full standalone network in Q3 of 2019. Investors Given the ambition of the IOST project, they’ve also managed to bring on board some top brass investors including the Chinese arm of leading Venture Capital firm Sequoia Capital. Some of their other prominent advisors include: Jia Tian, investor in Bitfinex, limited partner at Bitfund and a consultant for Zcash. BMan Lee, a consultant for Alibaba, Lenovo and Qihoo. He is the lead for Baidu’s AOD platform which serves more than 500,000 businesses. Ryan Bubinski, Co-Founder of Codecademy and listed as one of TIME Magazine’s 100 Most Influential People. Market Peformance: Looking at we can see that over the last 30-days IOST has seen strong performance even in the bear market seeing daily volumes between $30M and $150M since it began trading on . IOST on CoinCheckUp.com Binance In fact, , even in the bear market of early Q1/Q2 2018 — IOST grew by 56.45% in March, making it the 4th fastest growing of the top 50 coins, beating out investments like , , , and . IOST EOS Binance Coin Tron Bitcoin Ethereum So where can you get IOSToken right now? Binance HuobiPro OKEX Kucoin Bitfinex Disclaimers: The author of this article has not purchased any IOST nor do they intend to within the next 72 hours. The author of this article may be compensated by links in this content in line with various affiliate programs. Did you enjoy this article? Subscribe to the author for more! What coins are up next? Over the next few months I’m going to be deep diving coins like: Cardano Stellar NEO IOTA VeChain Ontology Wanchain Nebulas Kin Wax And many more, leave comments in the comment section to vote for your favourite, and don’t forget to subscribe so you never miss a detailed primer! Edit: An earlier version of this article called a number of prominent figures “investors” when they are in fact “advisors” for this project.

A Primer on IOSToken (IOST) — the Ethereum, EOS and IOTA competitor aiming to give machines…

The purpose of Hyperlambda is to have a programming language that allows your computer to generate most of your code. However, sometimes you need to manually modify the generated code yourself, and/or create Hyperlambda code manually, at which point you'll need to understand Hyperlambda. Hyperlambda is extremely easy to learn though, and you can probably teach yourself most of its basics in less than 10 minutes. This article is an introduction to Hyperlambda and gives you an overview of Hyperlambda from a bird's perspective. Structure Syntactically Hyperlambda resembles YAML, however, it has its own unique syntax, and even though it has the same readability traits as YAML, it is the same. In theory, we could have used YAML, JSON, or XML to create Hyperlambda, but that would increase its verbosity, resulting in more difficult-to-read code. However, its structure is easily understood in 5 minutes, since it is literally just a text representation of a tree structure. Hyperlambda's structure is based upon , and each node has 3 properties. not "nodes" Name Value Children To illustrate imagine the following Hyperlambda. .data
   foo1:bar1
   foo2:bar2 The above Hyperlambda consists of 3 nodes. The first node is called . This node has two children called and . Both of these nodes have a value each being and . The colon separates the node's name and its value, and 3 spaces opens up the children collection. To play around with Hyperlambda you can use Magic's component. Below is a screenshot of a slightly more complex example. [.data] [foo1] [foo2] "bar1" "bar2" "Evaluator" The above example is of course more complex than our first code snippet, but it still follows the exact same structure being name/value/children. In the above example, the node is given two children arguments; One condition node being its parts, and another lambda object being its parts. The loop will execute its object for as long as its condition is true. The condition again is an condition, implying . Translating the above Hyperlambda to English hence becomes the following. [while] [lt] [.lambda] [while] [.lambda] [lt] "less than" Execute .lambda while .no has a value less than 20 Inside we're creating a log entry before we increment the value. Magic contains many similar conditions, such as , , etc - In addition to a lot of additional . Refer to the for an exhaustive list. [.lambda] [.no] "more than" "equal" "keywords" magic.lambda documentation Code is data The reasons why Hyperlambda is so good at creating and modifying code, is because there is no difference in Hyperlambda between and - Implying code data. The same way we can modify data structures such as XML, YAML, or the HTML DOM for that matter, Hyperlambda allows for modifying its code. If you want to change the invocation to in the above screenshot to this is as easy as adding the following Hyperlambda to the top of your code. "code" "data" is [ ] log.info [log.error] set-name:x:../**/log.info
   .:log.error This trait of Hyperlambda makes it very easy to create , that somehow changes an existing snippet of code to do something completely different. This trait of Hyperlambda is crucial for its ability to automatically generate code and is the reason why it can with such ease create and generate code 100% automatically for you. When you think about Hyperlambda is, please understand its for being weird. Hyperlambda's allows us to easily create templated snippets of code that we use as the foundation for some process automatically generating custom code, by parametrizing our code dynamically, such that we can modify it according to our specific needs. "self evolving code" "how weird" reasons "weirdness" Everything is code The natural realization of the above is that all data is also code. This creates a problem for us since we might want to create nodes we don't want to . This is achieved by starting a node's name with a . This instructs the Hyperlambda execution engine that this node should not be executed but simply ignored by the Hyperlambda execution engine. This is what allows us to create , and/or nodes containing . You can see examples of such nodes in our previous code snippets and screenshots. "execute" "." "variables" "data" Expressions Hyperlambda doesn't have . This is because is a variable in Hyperlambda, including function invocations, arguments to functions, etc. This creates a problem for us, being that we need some mechanism to modify node names, node values, and their children collection. This is where expressions comes into the picture. An expression allows us to reference any node in our Hyperlambda object. An example of such an expression can be seen in the above screenshot where our invocation to has the value of . Its part declares it as an expression , while the part is the actual expression. An expression is similar to chained LINQ statements in that it is a list of objects, that reacts upon each other in a chain. Below is a slightly more complex expression to illustrate
the point. "variables" everything [get-value] :x:@.no :x: type @.no IEnumerable .data
   foo1:bar1
   foo2:bar2
   foo3:bar3

set-value:x:../*/.data/*/foo2
   .:Hyperlambda was here If you execute the above Hyperlambda in your Magic's component, you will see it changes the value to . This is because the expression we give our invocation basically says the following. "Evaluator" "bar2" "Hyperlambda was here" [set-value] Give me the root node, then all its children, then filter away everything not having the name of '.data', find its children again, and filter away everything not having the name of 'foo2' When the expression is done filtering our nodes, we're left with only the node, at which point changes its value. To understand expressions and type declarations in Hyperlambda you might benefit from reading about diving deeper into both expressions, iterators, and Hyperlambda's typing system. However, think of expressions as , where each pointer is composed from a chain of , where each iterator is separated by a slash (/), and your expression as a whole can
point to zero or more nodes. [foo2] [set-value] magic.node "pointers into your Hyperlambda object" "iterators" Slots Hyperlambda doesn't really understand the idea of function invocations. Instead everything is a in Hyperlambda. However, for all practical concerns a is similar to a function invocation in a traditional programming language. Magic contains hundreds of slots for all sorts of scenarios, and in the documentation for Magic we often refer to these using square brackets in text. To modify parts of your Hyperlambda the following slots are your most important friends. "slot" "slot" bold - Changes the value of one or more nodes [set-value] - Changes the name of one or more nodes [set-name] - Adds a bunch of children to some node [add] - Inserts a bunch of nodes some node [insert-before] before - Inserts a bunch of nodes some node [insert-after] after - Removes nodes [remove-nodes] By combining the above slots you have everything you need to be able to change your Hyperlambda objects as they are executing, resulting in a Turing complete programming language, even though it technically doesn't have neither functions nor variables. To see which slots are available you can click on Windows or on a Mac while your code editor has focus to open the autocomplete drop down. Below is a screenshot of the autocomplete drop down from Hyper IDE. CTRL+SPACE FN+CONTROL+SPACE Snippets Magic's component contains a lot of Hyperlambda snippets illustrating some aspect of Hyperlambda. If you click the button you can load existing Hyperlambda snippets demonstrating some aspect of the programming language for you. The easiest way to start learning Hyperlambda is probably to go through these snippets, understand what they do, for then to apply similar constructs in your own Hyperlambda. The loop in the first screenshot in this article is one example of such a snippet. You can also save your own snippets as you're playing around with Hyperlambda. is a video where I demonstrate Hyperlambda and what you can achieve with it. "Evaluator" "Load" [while] Here Orchestration Hyperlambda is an . This implies that it is a super high-level language, intended for programming building blocks. For these reasons some would argue it's not a programming language, which would be a correct assessment. If you're creating quick sort functionality or polygon rendering algorithms in Hyperlambda, you're doing something wrong. Hyperlambda is intended for algorithm-heavy snippets, even though technically it possible to implement anything in it. To understand Hyperlambda's position, realize its purpose is to sit between your algorithm-heavy low-level code, and the client, your low-level building blocks, giving you dynamic capabilities on your code as a whole. "orchestration programming language" "orchestrating" "real" not is "orchestrating" Hyperlambda is for your code the same as YAML is for your pipelines, configurations, and Kubernetes cluster, in that it allows you to your code together, using declarative concepts, from a high-level abstraction layer, where you don't have to think about the internal details of your executing code. However, where YAML allows you to configure the deployment of your applications, Hyperlambda allows you to your application instead of manually coding it using low-level programming languages such as C# or Java. "configure" "configure" However, when that's said, the entirety of Magic is actually created in Hyperlambda, implying its middleware, the IDE, the SQL editor, in fact, including the crudifier - And you can actually find this code inside your folder if you're using Hyper IDE to check out its code. If you're using heavy recursion, lots of nested while loops, and dozens of temporary variables in your Hyperlambda code, you would probably be better creating this part of your code in C# and exposing your C# code as a to your middleware instead. everything "system" "high level slot" Download Magic, everything is Open Source Also Published Here

Stories, News & Mentions about AISTA

Aista’s Stories on HackerNoon