Our mission is to make Americans better protected, and to do so we use data science and AI to transform the way employers and their workforce choose and use their health insurance and benefits - without the hassle

Nayya

nayya

Recently while working on a project, I had to create a functionality where users can download an excel file consisting of some data. In this process, since I am a big fan of E2E Testing with , I decided to write a test suite that could make sure that the excel is being downloaded correctly and also consists of the correct data that our users would expect. Cypress.io This article assumes a basic understanding of cypress. Disclaimer If you haven't tried e2e testing with cypress before, I would highly recommend skipping over to the section and following some of the getting started guides. References 📦 Installation 1) Assuming you have a repo named , create a new folder in it named . dashboard-ui e2e 2) into that folder and execute the following commands inside it cd npm init
npm install cypress --save-dev 3) Update the project’s scripts by opening and updating your scripts to the following: package.json : { : , : } "scripts" "cy:run" "cypress run --headless -b chrome" "cy:open" "cypress open" 4) You should also see some default folders and files created by cypress for you after you have installed cypress. 5) The test that we will write will go inside folder. integration ⚙️ Functionality For the sake of simplicity, let's say our application only has one feature where users can click on a button, which can download an excel file comprising of some data in it. download template On click of the download template button a file gets downloaded which looks something like this: Demo 🧪 E2E Testing 1) Create a new file inside folder with the name . integration ExcelDownload.spec.js 2) Inside this file our test would first start with checking for existence of our button and then we will click on it. cy.get( )
  .should( )
  .click(); "[data-test-id=export-template-btn" "be.visible" 3) After clicking on it, the file should ideally have been downloaded and now we need to somehow read that file and check if it exists and also check if it consists of the right data in it. 4) To do that, we will first need to install another npm package which can parse the excel and convert it to a json npm install node-xlsx --save-dev 5) After this inside your file we will create a new task plugins/index.js xlsx = ( ).default; fs = ( ); path = ( ); .exports = { on( , {
    parseXlsx({ filePath }) { ( { { jsonData = xlsx.parse(fs.readFileSync(filePath));
          resolve(jsonData);
        } (e) {
          reject(e);
        }
      });
    }
  });
}; const require "node-xlsx" const require "fs" const require "path" module ( ) => on, config // `on` is used to hook into various events Cypress emits "task" return new Promise ( ) => resolve, reject try const catch This function will parse our excel file and convert it to json. 6) Finally let’s complete our test for excel file download data = [ , , , , , , ]; cy.get( )
    .should( )
    .click(); cy.wait( ); cy.parseXlsx( ).then( { expect(jsonData[ ].data[ ]).to.eqls(data);
  }
); // data to check against const "id" "config_sku" "simple_sku" "fallback_type" "field" "value" "command" // check for existence of the button on the ui and then click it "[data-test-id=export-template-btn" "be.visible" // arbitrary wait so that the download can complete 2000 // call the parseXlsx task we created above to parse the excel and return data as json "/Users/Downloads/overrides-template.xlsx" => jsonData // finally we write the assertion rule to check if that data matches the data we expected the excel file to have. 0 0 7) With this we can be sure that our excel download functionality is working as expected. Test Execution 8) The only caveat here is how do you know the download path for your CI/CD Pipeline or how can you change that path to something else. The solution to that is built into cypress. Again inside file we will create another task. plugins/index.js on( , (browser = {}, launchOptions) => { downloadDirectory = path.join(__dirname, , ) (browser.family === ) {
   launchOptions.preferences.default[ ] = { : downloadDirectory }
  } launchOptions;
}); "before:browser:launch" const '..' 'excelDownloads' if 'chromium' 'download' default_directory return Here we are changing the default directory of download to a directory named inside of cypress folder. excelDownloads https://docs.cypress.io/api/plugins/browser-launch-api.html#Change-download-directory 💡 Conclusion In conclusion, E2E tests are really important for every app and you should write one too because this is the closest you can get to test how an actual user will use your application. And as says: @tlakomy Sleep better at night with e2e tests and cypress.io 👯 Share this article if you found it helpful! You can follow me on twitter for more updates. @VivekNayyar09 Also please don't forget to maintain social distance to prevent the virus from spreading and wash your hands regularly. Stay safe and stay at home. 🚀 References https://softchris.github.io/pages/cypress.html https://docs.cypress.io/guides/getting-started/installing-cypress.html#System-requirements https://dev.to/tlakomy/sleeping-better-at-night-with-cypress-io-59m2 https://blog.logrocket.com/how-to-write-useful-end-to-end-tests-with-cypress/ Previously published at https://dev.to/viveknayyar/e2e-testing-of-excel-downloads-with-cypress-21fb

E2E Testing of Excel Downloads with Cypress

Hola people!!! 🥑 It’s been a while since I have written a blog and now since most of us are working from home, the time that used to go in commute is now saved and I thought why not utilize this time and write about my recent experience of fixing a security vulnerability. So if any of you in the recent time have seen something like this image below and have no clue how to fix it then this article is for you. When I saw it, I had no clue either but with some research I could fix this. 🔬 Problem: So what this means is one of the dependencies in your has some security implications which can be exploited by an attacker and can cause problems for you, your product or the company you work for. package.json For example: https://snyk.io/vuln/npm:eslint:20180222 This vulnerability could have caused a Regular Expression Denial of Service 💡 Finding: In order to find potential vulnerabilities in your repo, you can either do 1) npm audit — which should show you an output like the following image: 2) Github security policy can also notify you — something like the following image: Today when I started working I had to deal with this error where and were being reported as security vulnerabilities. acorn minimist 🎉 Solution Solution to this problem is in steps:- 📦 npm update 1) This is the first thing you should do and it's the simplest one too. Run npm update — https://docs.npmjs.com/cli-commands/update.html Delete your package-lock.json file or for yarn users, delete your yarn.lock file. In an ideal world this would work, but there might be some dependency which does not follow semver and might get updated too. So a better solution here would be to only delete the lines corresponding to the vulnerable package in your package-lock.json(or yarn.lock) file. Run npm install again In an ideal scenario, this should have upgraded your dependencies to the next semver version and those libraries might have already fixed the version of there transitive dependencies. 🔭 npm audit 2) But if that did not fix your issue, which for did not fix for me, then follow the below mentioned steps: minimist 2.1) To fix any dependency, you need to first know which npm package depends on that. npm audit This will tell you the packages which are vulnerable. This tells me that is required by and that is required by minimist mkdirp mocha. A quick glance into package-lock.json can give you more information around the affected version. In my case mocha(7.1.0) -> mkdirp(0.5.1) -> minimist(0.0.8) — the vulnerable version. 🔑 Resolutions key 3) And finally the fix was: 3.1) First npm install the non-vulnerable version, which in my case was 1.2.5 npm install minimist --save-dev For and users yarn npm 3.2) Add a resolutions key in your package.json file { : { : }
} "resolutions" "minimist" "^1.2.5" For npm users, we need one more step for that resolutions key to work. 3.3) Use npm-force-resolutions ( ) https://www.npmjs.com/package/npm-force-resolutions : { : } "scripts" "preinstall" "npx npm-force-resolutions" 3.4) After that run npm install That’s it. That solves the dependency issues which can not be updated using either npm update or by uninstalling and reinstalling a new dependency. To check if the dependency works correctly npm ls minimist This should give you an output like the image below 🔥 Disclaimer If some packages are only compatible with an older version, then this change might break your app. So be careful while resolving to a particular version and test your app before releasing this change. 👯 Share this article if you found it helpful! You can follow me on twitter for more updates. @VivekNayyar09 Also please don’t forget to maintain social distance to prevent the virus from spreading and wash your hands regularly. Stay safe and stay at home. Previously published at https://dev.to/viveknayyar/fixing-security-vulnerabilities-in-npm-dependencies-in-less-than-3-mins-2p5g

How to fix Security Vulnerabilities in NPM Dependencies in 3 Minutes

( Magical land of React Suspense, Concurrent React and React.lazy API) in his talk “ ” at JSConf Iceland 2018 said: Dan Abramov Beyond React 16 We’ve built a generic way to ensure that high-priority updates like user input don’t get blocked by rendering low-priority updates. Let’s understand what this means and also get introduced to some of the new features coming to React, some of which have been released as part of the latest stable release and some of them are still in mode and it’s quite possible that the implementation of the api might change over time. unstable Things we got introduced to in the talk: Suspense Defer set state with react-cache scheduler Concurrent React ModeCode splitting with React.lazy Suspense React.Suspense in simple words means we can suspend the rendering of our component or components until some condition is met( for example data from an endpoint or a resource is loaded) and until then show a fallback(for-example a spinner) Why do we need this? If suspense is all about just showing a spinner till data loads, can we not do that today as well? I mean we have been doing the same thing since a long time by keeping a loading state as true and till the data is not fetched we show a spinner and when data fetch is complete we set the loading state to false. An example of how we have been currently doing it: state = { : , : } loading true data null So the question is if it can be done even today then what is it that suspense is bringing into our codebase? The answer to that is yes it’s still possible to use loading state and play around with it to show/hide the spinner but as the application grows complex this becomes tedious to manage. For example:- <RestaurantDetail> <RestaurantAlbums /> <RestaurantReviews>
        <RestaurantReviewDetail>
        <RestaurantReviewDetail>
        <RestaurantReviewDetail>
        {...}
    </RestaurantReviews>
</RestaurantDetail> < /> RestaurantInfo In the above example we can have 4 api calls: 1) component making one api call for getting basic information about a Restaurant <RestaurantInfo /> 2) api to fetch all the images of that Restaurant 3) api to fetch all reviews 4) api to fetch some details around those individual reviews like comments, likes etc. <RestaurantAlbums /> <RestaurantReviews /> <RestaurantReviewDetail /> The problem with the above code structure is that we need to somehow manage the loading state and data fetching states for all those api calls that are happening above. So what is the solution? For the above problem we have multiple solutions which can be as follows: Delegate all api calling logic into the parent container and let all of them wait until all data fetching is complete and pass data to child components as props. The problem with this approach is now the parent needs to be aware of all api calls which are needed by child components and also maintain a complex state for all these api responses. Make all the child components smart/stateful components and let each of them manage their own and states. This is complex since converting a stateless component to a stateful component is not something we would want to do. loading data The third solution is using Suspense With Suspense it works differently. How? With suspense and react-cache, we can use our same functional component and still fetch data from it. The difference here being instead of fetching data from a lifecycle method like we will fetch this data from inside of . componentDidMount render How is this even possible? This becomes possible using react-cache and suspense Now a word of caution, is still unstable and it’s implementation or api might change over time. react-cache An example of how to use react-cache to create a restaurant list fetching resource:- {
  unstable_createResource,
} ; restaurantListResource = unstable_createResource( { ( {
    fetch( )
      .then( res.json())
      .then( { { restaurants } = response;
        resolve(restaurants);
      });
  });
}); import from "react-cache" const => () return new Promise ( ) => resolve, reject "https://8kq2vljq58.sse.codesandbox.io/restaurants" => res => response const react-cache In the above code snippet we are using and as the name suggests this is still unstable_createResource unstable. unstable_createResource takes a function as one of its arguments and a hash function as the second argument which is used to create the key for the hash map which caches the data. The whole suspense and suspended rendering magic comes into play with this because this function unstable_createResource throws a promise. (Dan’s tweet about cache throwing a promise and react catching it) A layman implementation of what it might look like could be: unstable_createResource = { resolved = (); {
    read(key) => { (!resolved.has(key)) { method(...args)
          .then( resolved.set(key, val));
      } resolved.get(key);
    }
  };
} const ( ) => method let new Map return if throw => val return If you notice, it returns an object with a function which takes as a param which is usually the hash key of the hash map and if the data is not fetched yet then this read function will as we see on line no 6. read key throw a promise The actual implementation of this function can be found here:- https://github.com/facebook/react/blob/master/packages/react-cache/src/ReactCache.js#L142 Who will catch this promise? will catch this promise like how they used to catch the error thrown by React render. More information on Error Boundaries can be found on reactjs.org: Error Boundaries https://reactjs.org/docs/error-boundaries.html So now with our component would look something like this: unstable_createResource RestaurantList RestaurantList = { restaurants = restaurantListResource.read(); ( <h2 className="f3 fw4 pa3 mv0">Restaurant List</h2> <div className="cf pa2">{renderRestaurants(restaurants)}</div> );
}; const => () // if no restaurants are found in the cache, the suspense will throw a promise const // this line will have to wait until that promise resolves return < > article </ > article Who will implement componentDidCatch? This is where from react comes into play. has a sort of mechanism which will catch this promise and show a fallback until the promise is resolved. Suspense React.Suspense componentDidCatch React, { Suspense } ; RestaurantListContainer = { ( <RestaurantList /> );
}; import from 'react' const => props return < = ' '}> Suspense fallback { Loading... </ > Suspense This concludes the topic of using React.Suspense to suspend rendering until data fetching is complete and until then show a fallback. We learnt about in this topic and how it can be used to throw a promise and suspend rendering. react-cache Concurrent React To take advantage of the asynchronous capabilities of concurrent React, We change the way we render our root element. <App /> Where we do this in standard React: render(&lt;App /&gt;, document.get ); . ReactDOM ElementById(' ') root We do this for concurrent React: create ).render(&lt;App /&gt;); . ReactDOM Root( . (' ') document getElementById root That is all that needs to be changed to enable Concurrent React. This brings us with a new magical capability which is:- prop- this is the time in after which our fallback component will show up. This will avoid screen flickering issue which usually occurs on faster network where the loader shows up for few ms and then the data comes immediately. This will make sure that for faster networks Spinner will never show up thereby avoiding screen flickering. maxDuration ms React.StrictMode If you are developing in React 16.6, what has been recommended is to wrap <React.StrictMode> around <App /> so any unsupported features you may integrate will be prompted as warnings in your development console. Wrap strict mode around your app like so: ReactDOM.render( <App /> < > React.StrictMode , document.getElementById('root')); </ > React.StrictMode Defer Mode in Concurrent React We can defer certain setState calls and let it wait until some other important operations like data fetching finishes for example clicking on a restaurant card and not rendering the detail page until all the data for the detail page has been loaded. This is the kind of stuff it allows you to do: To use this we need another api which is part of an package called as unstable npm scheduler { unstable_scheduleCallback defer } https://www.npmjs.com/package/schedule _blank ; import as from "<a href=" r" target=" ">scheduler</a>" To defer a setState call we can do like the function below where I am delaying showing the detail page until the data for that page is loaded. { unstable_scheduleCallback defer } ;
...

toggleDetailPage = { (id) { .setState({ : id
    });
    defer( { .setState({ : });
    });
  } { .setState({ : id, : });
  }
}; import as from "scheduler" => id if this id => () this showDetail true else this id showDetail false Defer is also able to somewhat catch the thrown promises, and only apply the state changes after all of the child async operations are completed. Complete example with concurrent react, createResource, Suspense and defer mode can be found here https://codesandbox.io/s/kwjjovx5wo Here is what Dan had to say about this whole set state defer: Code Splitting with React.lazy and React.Suspense The React.lazy function lets you render a dynamic import as a regular component. Before: React ; RestaurantListComponent ; { ( <RestaurantListComponent /> );
} import from 'react' import from './RestaurantList' ( ) function App return < > div </ > div : In the above implementation the will be part of your main bundle and will not be lazy-loaded. Note RestaurantListComponent After: React, { Suspense, lazy } ; RestaurantListComponent = lazy( ( )); { ( <RestaurantListComponent /> );
} import from 'react' const => () import './RestaurantList' // code-splitted, on demand loaded component ( ) function App return < = > Suspense fallback "Loading..." </ > Suspense : With this approach, will be a code splitted component loaded on demand. Note RestaurantListComponent Example of lazily loaded component in a chunk “ 1.chunk.js” How to use these API’s? React.Suspense with React.lazy is a stable API and can be installed from npm as the latest stable version of react and react-dom npm react react-dom install react-cache and scheduler are unstable. Here is how you can still use them: npm install react@ -alpha - next
npm install react-dom@ -alpha - next
npm install react-cache@ -alpha npm install scheduler@ 16.7 .0 .2 16.7 .0 .2 2.0 .0 .1 0.11 .2 Conclusion To conclude, I am really excited about all these api’s to be stable soon. What are your thoughts on these features? Let me know in the comments section! 😊 Here is the roadmap from the React team for the upcoming releases: https://reactjs.org/blog/2018/11/27/react-16-roadmap.html Resources React lazy, Suspense and Concurrent React Breakdown with Examples Beyond React 16: Time Slicing and Suspense API Dan’s JSCONF talk React Suspense: Async Rendering in React What’s new in React — Presentation Fresh Concurrent React Twitter thread around this topic Special thanks to for reviewing this 😊 Sara Vieira

Magic of React Suspense with concurrent react and React.lazy API

I finally started working on a React native app last week and to be honest I have been thinking of doing so since an year now, but always lacked the motivation to start. A few weeks back I was reading this book “The Subtle Art of Not Giving a F*ck” and I came across this quote which gave me a final push to start writing a React Native App. The quote is: Action isn’t just the effect of motivation; it’s also the cause of it. And with that thought, let’s begin. Intent This article is about how to have a custom component for header, bottom tab navigation when you are using and how to style it since it took me one complete day to figure out all of it! It really took a lot of research, google search and reading all the github solutions by others, of which some did work and some did not. React-Navigation Here is how the final screen with custom header and tab look like: The entire code can be found here and can be tested with . expo So lets begin 😄 Pre-Requisites We are using 0.55.2 version and 2.0.0 React Native React navigation Follow the getting started guide from here to create a new react native app from scratch and then create a routes file similar to the one mentioned below. _This page will help you install and build your first React Native app. If you already have React Native installed, you…_facebook.github.io Getting Started · React Native Alternatively you can also install package. create-react-native Your route file should look like the following gist: is a function that returns a React component. It takes and, optionally, [createStackNavigator](https://reactnavigation.org/docs/en/hello-react-navigation.html) a route configuration object an options object Approach In this section, I have put down all the FAQs about customizing the header.We will use the solution for each of them to create our customized header. How do I use a custom header for my React navigation? Solution: Inside the options object of , we have .Inside this object we can specify our custom header like this. _createStackNavigator_ _navigationOptions_ header: props => <CustomHeader {...props} /> Also this won’t work unless you also make the background transparent for the react navigation header with this line of code:- headerStyle: {backgroundColor: "transparent"} Finally, after adding the custom header, our code will look like the following gist: And the CustomHeader.js file in my case looked like this: What if I do not want a custom header and just want to style my header? Solution:- Use **headerStyle** How do I style my header title? Solution: Use **headerTitleStyle** How do I change the color of the back arrow? Solution: Use **headerTintColor** headerTintColor: “#fff” How do I hide the back arrow? Solution:- Use and set it to **headerLeft** **null** headerLeft: null What if I do not want to show a header for some screens? Solution: Set **header** to **null** header: null The final code after all the changes would look like this: That pretty much should solve most of the customization regarding custom header. Up next is if I am using a for bottom tab navigation, how do I style the header for tabs and the bottom navigation? TabNavigator With TabNavigation and Header, the process is slightly complicated. You cannot have this tab approach if you wish to have different headerTitle for your header with respect to each tab. So the solution here is putting each of your tab screen inside a stackNavigator. For example:- Frequently Asked Questions about Bottom TabBar? How do I put a custom bottom navigation bar for React navigation? Solution: React Navigation TabNavigator accepts a property **tabBarComponent** . We can specify our custom component here. tabBarComponent: CustomTabBarBottom How do I style my bottom TabBar? Solution: Use object and the property to style your bottom tab bar. **tabBarOptions** **style** How do I add icons to my bottom navbar? Solution: Use object property. **navigationOptions** **tabBarIcon** How do I hide the bottom tab bar for some detailed screens which are sub screen’s of a parent tab? For example you might have a movie tab which shows a list of movies and on clicking on any of those you would want to show the details of that movie and would want to hide the bottom navbar and disable swiping as well. In all such cases, here is what you need to do: From your parent tab when you navigate to the details page, send it a param of **hideTabBar: true** this.props.navigation.navigate('DetailsScreen', {hideTabBar: true}); 2. Now inside of your , have code like this: **navigationOptions** **TabNavigator** Finally after all the changes, the tab router looks like this: Conclusion Hopefully this article saves someone’s time while getting started with React Native. React native is fun to play around and to create cool apps 😍 ✨ Give this article a clap if you found it helpful! And do share the amazing apps that you all have created or are working on in the comments section. Let’s all learn together… 😃 You can follow me on twitter for more updates on what I am experimenting with. @VivekNayyar09 For further reading, please refer to the following links:- React Native getting started fluent-conf-restaurant-app React Navigation Custom Header Github Issue(this helped me a lot to debug my issues)

How to use a Custom Header and Custom bottom tab bar for React Native with React Navigation?

🕵️‍ Confusion: When I first started working with React, I always had this confusion that even though my functional component has no reference to React(since I could not see any mention of React keyword in the component), then why do I need to have at the top of my file. 😕 import React from “react"; This is how we create a simple functional component in react:- 🔬 Problem: This code looks like a very simple function with some html inside it but it fails to work if we use it without import React from "react" The problem here is if it’s just some function with html inside it, then it should work without the import statement 🤔 😍 Finding: After reading more about it and after seeing the code which get’s generated after transpilation, I could finally understand why it’s needed 😯 The reason is because of 😃The code which looked like plain html to me is actually JSX 🙇 JSX So after babel transpilation, this is how the same code looks var App = function App() {return React.createElement("div",null,"Hello World!!!");}; The important thing to focus here is and this is the reason why we need to import React at the start of any functional component. 🎉 🙌 React.createElement Hope this helps anyone who is starting with React and is confused about why is needed. import React from “react" For further reading as to understand what gets transpiled to what, please try the Babel REPL The compiler for writing next generation JavaScriptbabeljs.io Babel · The compiler for writing next generation JavaScript Give this article a clap if you found it helpful! You can follow me on twitter for more updates on what I am experimenting with. @VivekNayyar09

Why import React from “react” in a functional component?

and it brings lots of exciting changes. One of the features that got me excited is better error handling. Previously, runtime errors during rendering could put React in a broken state. React 16 is here With React 16, instead of unmounting the whole app every time there’s an error, you can use error boundaries. Think of error boundaries like try-catch statements, but for React components. Error boundaries are React components that catch JavaScript errors anywhere in their child component tree, log those errors, and display a fallback UI instead of the crashed component tree. A class component becomes an error boundary if it defines a new lifecycle method called componentDidCatch(error, info). With error boundaries, even if one of your component’s results in an error, the entire react app would not get unmounted and instead only the erroneous component would display a fallback UI and the entire app would still be fully functional. To demonstrate the usage of an error boundary in a React App, we would be taking an example of an e-commerce website which has a product listing page to display what all products are available for sale. The final page would look something like this:- If you were to notice the last product card, it shows a kind of an error template. Because of Error Boundaries in React 16, we were able to place a fallback UI template for that particular component and still render the entire app. An Error Boundary class component can be created in the following manner:- And we can then wrap any of our component’s inside Error Boundary component to catch error’s and display a fallback UI. For example:- <ErrorBoundary>  <ProductCard /></ErrorBoundary> The method works like a JavaScript block, but for components. Only can be error boundaries. componentDidCatch() catch {} class components Inside we set the state to true and then inside our render method based on whether hasError is true or false we render either the fallback UI or the React Component’s that we wanted to render as children’s. componentDidCatch() hasError For our app we have primarily three components:- ProductList Component ( Smart Component) Product Component (Presentational Component) Header Component (Presentational Component) For styling I am using React Toolbox . The code for the Component is as follows:- ProductList As you can see the Product Component is wrapped inside Error Boundary. And the code for component is:- Product In the above Product.js code we are calling props.product.name.toUpperCase() So whenever a product has no name to it, then the function would be called with and would result in an error which would eventually result in of the entire react app. toUpperCase undefined unmounting But with Error Boundary in place, we can catch these error’s and render a fallback UI like the one below:- I hope this demo helps in understanding Error Boundaries of React 16. React 16 has many more great features shipped in and I would be discussing more about them in my next article. The entire code for the above demo app can be found on my github repo, the link for the same is:- _React-16---Error-Boundaries - Repo to demonstrate the usage of Error Boundaries in React 16_github.com vivek12345/React-16---Error-Boundaries For further reading, please refer to the following links:- Error Handling in React 16 Egghead.io React Error Handling

Error Boundaries in React 16

In this exclusive interview, Andrey Nayman, co-founder of Magic Square, shares his journey in the blockchain industry and the inspirations behind creating a community-driven App Store. Ishan Pandey: Hi Andrey, great to have you here. To start off, could you share a bit about your background and what inspired you to co-found Magic Square? Andrey Nayman: I've been in the blockchain industry since 2013. My experiences leading various tech companies inspired me to start Magic Square. We're building a community-driven App Store that makes using decentralized apps simpler and safer. I’m passionate about using my blockchain knowledge to create something valuable and innovative for users worldwide. Ishan Pandey: Magic Square offers a unique ecosystem for discovering Web3 projects. Can you explain what sets Magic Store apart from other platforms in the space? Andrey Nayman: Magic Square is all about putting users first. Imagine it like a big online store, but instead of selling physical items, we present Web3 Apps. Magic Store is a way for users to discover all trusted Dapps and engage with them in one place. What makes us different is that we check every app really carefully before putting it in our store. This makes our platform safe and easy to use, whether you're new to Web3 or already an expert. Ishan Pandey: Given the diverse offerings within the Magic Square ecosystem like Magic Karma and Hot Offers, how do these features enhance the user experience and engagement? Andrey Nayman: Magic Karma and Hot Offers are innovative features designed to enhance the user experience on Magic Square. Magic Karma serves as our reputation system – users receive daily rewards for contributing to the Magic Ecosystem, such as trying out new apps or participating in community activities, earning them points. These points can then be exchanged for exciting rewards. On the other hand, Hot Offers form our engagement layer, where users can complete tasks provided by the listed projects and receive real payments for their efforts. Together, these features keep our users happy and engaged while using our platform. Ishan Pandey: The $SQR token plays a central role in the Magic Square community. Could you discuss how it integrates into the ecosystem and what its benefits are for users? Andrey Nayman: The $SQR token is like the heart of Magic Square. Users earn $SQR as a reward for doing things on our platform every day. You can stake $SQR to unlock special benefits if you're a member. You'll get paid in $SQR when you earn rewards through Hot Offers. We also use $SQR to reach the right people in our marketing efforts. To join Launchpad sales, you must stake even more $SQR. So, $SQR is important for everyone using Magic Square. It's what keeps everything running smoothly and helps our community grow. Ishan Pandey: Community-driven platforms depend heavily on user participation. How does Magic Square encourage community involvement in project voting and validation? Andrey Nayman: Community is at the core of every crypto project. At Magic Square, we believe in bringing the crypto community together in one place. Here, users can decide which projects make it onto our platform, shaping their future. Our community moderators actively gather feedback, which our product team uses to create a roadmap aligned with their needs. To make our community feel valued and engaged, we offer daily rewards through Karma Points and exciting opportunities through Hot Offers. We also host regular surveys where users can share their ideas and feedback, ensuring our platform evolves based on their input. Ishan Pandey: Affiliate programs are common in Web3, but Magic Boost offers a unique twist. Can you elaborate on how this program works and what its advantages are for both users and developers? Andrey Nayman: Affiliate programs are common in Web3, but Magic Boost offers a unique twist. Here's how it works: Users can easily monetize their communities by sharing affiliate offers from listed projects. With one click, they share these offers on social media. When their friends engage and convert, users receive instant payouts. This benefits the user by allowing them to earn effortlessly while supporting their favorite projects. For developers, Magic Boost expands their reach and boosts user acquisition, enhancing app visibility and credibility. Ishan Pandey: Looking forward, what are some key developments or milestones that the Magic Square community can anticipate in the near future? Andrey Nayman: In the near future, our Launchpad will be a big focus. It's designed to help projects grow steadily and connect with our community. We'll customize our approach, using both public and private sales, to give projects the best chance of success. With our active community, we'll make sure these projects get plenty of attention. Stay tuned for more updates as we work together to shape the future of Web3! Don’t forget to like and share the story! Vested Interest Disclosure: This author is an independent contributor publishing via our business blogging program. HackerNoon has reviewed the report for quality, but the claims herein belong to the author. #DYOR. In this exclusive interview, Andrey Nayman, co-founder of Magic Square, shares his journey in the blockchain industry and the inspirations behind creating a community-driven App Store. Ishan Pandey: Hi Andrey, great to have you here. To start off, could you share a bit about your background and what inspired you to co-found Magic Square? Ishan Pandey: Hi Andrey, great to have you here. To start off, could you share a bit about your background and what inspired you to co-found Magic Square? Ishan Pandey: Hi Andrey, great to have you here. To start off, could you share a bit about your background and what inspired you to co-found Magic Square? Andrey Nayman: I've been in the blockchain industry since 2013. My experiences leading various tech companies inspired me to start Magic Square. We're building a community-driven App Store that makes using decentralized apps simpler and safer. I’m passionate about using my blockchain knowledge to create something valuable and innovative for users worldwide. Andrey Nayman: Ishan Pandey: Magic Square offers a unique ecosystem for discovering Web3 projects. Can you explain what sets Magic Store apart from other platforms in the space? Ishan Pandey: Magic Square offers a unique ecosystem for discovering Web3 projects. Can you explain what sets Magic Store apart from other platforms in the space? Ishan Pandey: Magic Square offers a unique ecosystem for discovering Web3 projects. Can you explain what sets Magic Store apart from other platforms in the space? Andrey Nayman: Magic Square is all about putting users first. Imagine it like a big online store, but instead of selling physical items, we present Web3 Apps. Magic Store is a way for users to discover all trusted Dapps and engage with them in one place. What makes us different is that we check every app really carefully before putting it in our store. This makes our platform safe and easy to use, whether you're new to Web3 or already an expert. Andrey Nayman: Ishan Pandey: Given the diverse offerings within the Magic Square ecosystem like Magic Karma and Hot Offers, how do these features enhance the user experience and engagement? Ishan Pandey: Given the diverse offerings within the Magic Square ecosystem like Magic Karma and Hot Offers, how do these features enhance the user experience and engagement? Ishan Pandey: Given the diverse offerings within the Magic Square ecosystem like Magic Karma and Hot Offers, how do these features enhance the user experience and engagement? Andrey Nayman: Magic Karma and Hot Offers are innovative features designed to enhance the user experience on Magic Square. Magic Karma serves as our reputation system – users receive daily rewards for contributing to the Magic Ecosystem, such as trying out new apps or participating in community activities, earning them points. These points can then be exchanged for exciting rewards. On the other hand, Hot Offers form our engagement layer, where users can complete tasks provided by the listed projects and receive real payments for their efforts. Together, these features keep our users happy and engaged while using our platform. Andrey Nayman: Ishan Pandey: The $SQR token plays a central role in the Magic Square community. Could you discuss how it integrates into the ecosystem and what its benefits are for users? Ishan Pandey: The $SQR token plays a central role in the Magic Square community. Could you discuss how it integrates into the ecosystem and what its benefits are for users? Ishan Pandey: The $SQR token plays a central role in the Magic Square community. Could you discuss how it integrates into the ecosystem and what its benefits are for users? Andrey Nayman: The $SQR token is like the heart of Magic Square. Users earn $SQR as a reward for doing things on our platform every day. You can stake $SQR to unlock special benefits if you're a member. You'll get paid in $SQR when you earn rewards through Hot Offers. We also use $SQR to reach the right people in our marketing efforts. Andrey Nayman: To join Launchpad sales, you must stake even more $SQR. So, $SQR is important for everyone using Magic Square. It's what keeps everything running smoothly and helps our community grow. Ishan Pandey: Community-driven platforms depend heavily on user participation. How does Magic Square encourage community involvement in project voting and validation? Ishan Pandey: Community-driven platforms depend heavily on user participation. How does Magic Square encourage community involvement in project voting and validation? Ishan Pandey: Community-driven platforms depend heavily on user participation. How does Magic Square encourage community involvement in project voting and validation? Andrey Nayman: Community is at the core of every crypto project. At Magic Square, we believe in bringing the crypto community together in one place. Here, users can decide which projects make it onto our platform, shaping their future. Our community moderators actively gather feedback, which our product team uses to create a roadmap aligned with their needs. To make our community feel valued and engaged, we offer daily rewards through Karma Points and exciting opportunities through Hot Offers. We also host regular surveys where users can share their ideas and feedback, ensuring our platform evolves based on their input. Andrey Nayman: Ishan Pandey: Affiliate programs are common in Web3, but Magic Boost offers a unique twist. Can you elaborate on how this program works and what its advantages are for both users and developers? Ishan Pandey: Affiliate programs are common in Web3, but Magic Boost offers a unique twist. Can you elaborate on how this program works and what its advantages are for both users and developers? Ishan Pandey: Affiliate programs are common in Web3, but Magic Boost offers a unique twist. Can you elaborate on how this program works and what its advantages are for both users and developers? Andrey Nayman: Affiliate programs are common in Web3, but Magic Boost offers a unique twist. Here's how it works: Users can easily monetize their communities by sharing affiliate offers from listed projects. With one click, they share these offers on social media. When their friends engage and convert, users receive instant payouts. This benefits the user by allowing them to earn effortlessly while supporting their favorite projects. For developers, Magic Boost expands their reach and boosts user acquisition, enhancing app visibility and credibility. Andrey Nayman: Ishan Pandey: Looking forward, what are some key developments or milestones that the Magic Square community can anticipate in the near future? Ishan Pandey: Looking forward, what are some key developments or milestones that the Magic Square community can anticipate in the near future? Ishan Pandey: Looking forward, what are some key developments or milestones that the Magic Square community can anticipate in the near future? Andrey Nayman: In the near future, our Launchpad will be a big focus. It's designed to help projects grow steadily and connect with our community. We'll customize our approach, using both public and private sales, to give projects the best chance of success. With our active community, we'll make sure these projects get plenty of attention. Stay tuned for more updates as we work together to shape the future of Web3! Andrey Nayman: Don’t forget to like and share the story! Vested Interest Disclosure: This author is an independent contributor publishing via our business blogging program. HackerNoon has reviewed the report for quality, but the claims herein belong to the author. #DYOR. Vested Interest Disclosure: This author is an independent contributor publishing via our business blogging program . HackerNoon has reviewed the report for quality, but the claims herein belong to the author. #DYOR. Vested Interest Disclosure: business blogging program business blogging program

Andrey Nayman Reveals the Vision Behind Magic Square's Unique Web3 Ecosystem

This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license.
Authors:
(1) Brisha Jain, Independent researcher India and brishajain02@gmail.com;
(2) Mainack Mondal, IIT Kharagpur India and mainack@cse.iitkgp.ac.in. Table of Links Abstract and Intro
Related Work
Data Collection
Analysis Methodology
Results
Limitations
Concluding Discussion
References REFERENCES [1] Toril Aalberg and Anders Todal Jenssen. 2017. Gender Stereotyping of Political Candidates. Nordicom Review 28, 1 (2017), 17–32. https://doi.org/10.1515/nor-2017-0198 [2] Pushkal Agarwal, Nishanth Sastry, and Edward Wood. 2019. Tweeting MPs: Digital Engagement between Citizens and Members of Parliament in the UK. Proceedings of the International AAAI Conference on Web and Social Media 13, 01. [3] Arshia Arya, Soham De, Dibyendu Mishra, Gazal Shekhawat, Ankur Sharma, Anmol Panda, Faisal M Lalani, Parantak Singh, Ramaravind Kommiya Mothilal, Rynaa Grover, Sachita Nishal, Saloni Dash, Shehla Rashid Shora, Syeda Zainab Akbar, and Joyojeet Pal. 2022. DISMISS: Database of Indian Social Media Influencers on Twitter. [4] Nichole M. Bauer. 2015. Emotional, Sensitive, and Unfit for Office? Gender Stereotype Activation and Support Female Candidates. Political Psychology 36, 6 (2015), 691–708. [5] Aditi Bhowmick, Paul Novosad, Sam Asher, Elliott Ash, Bilal Siddiqi, Christoph Goessmann, Daniel Chen, and Tanaya Devi. 2021. In-Group Bias in the Indian Judiciary: Evidence from 5.5 Million Criminal Cases. In Proceedings of the 4th ACM SIGCAS Conference on Computing and Sustainable Societies (COMPASS ’21). 47. https://doi.org/10.1145/3460112.3471943 [6] Jose Camacho-Collados, Kiamehr Rezaee, Talayeh Riahi, Asahi Ushio, Daniel Loureiro, Dimosthenis Antypas, Joanne Boisson, Luis Espinosa-Anke, Fangyu Liu, Eugenio Martínez-Cámara, et al. 2022. TweetNLP: Cutting-Edge Natural Language Processing for Social Media. In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing: System Demonstrations. [7] Tessa M. Ditonto, Allison J. Hamilton, and David P. Redlawsk. 2014. Gender Stereotypes, Information Search, and Voting Behavior in Political Campaigns. Political Behavior 36, 2 (2014), 335–358. https://doi.org/10.1007/s11109-013-9232-6 [8] Kathleen Dolan and Timothy Lynch. 2014. It Takes a Survey: Understanding Gender Stereotypes, Abstract Attitudes, and Voting for Women Candidates. American Politics Research 42, 4 (2014), 656–576. https://doi.org/10.1177/1532673X13503034 [9] Heather Evans. 2016. Do Women Only Talk about ‘Female Issues’? Gender and
Issue Discussion on Twitter. Online Information Review 40, 5 (2016), 660–672.
https://doi.org/10.1108/OIR-10-2015-0338 [10] Heather K. Evans and Jennifer Hayes Clark. 2016. You Tweet Like a Girl!’: How Female Candidates Campaign on Twitter. American Politics Research 44, 2 (2016), 326–352. https://doi.org/10.1177/1532673X15597747 [11] Peter A. Gloor, Joao Marcos, Patrick M. de Boer, Hauke Fuehres, Wei Lo, and Keiichi Nemoto. 2015. Cultural Anthropology through the Lens of Wikipedia: Historical Leader Networks, Gender Bias, and News-based Sentiment. arXiv:1508.00055 [cs.CY] https://doi.org/10.48550/ARXIV.1508.00055 [12] Leonie Huddy and Nayda Terkildsen. 1993. Gender Stereotypes and the Perception of Male and Female Candidates. American Journal of Political Science 37, 1 (1993), 119. https://doi.org/10.2307/2111526 [13] Berrin Beasley John H. Parmelee, Nataliya Roman and Stephynie C. Perkins. 2019. Gender and Generational Differences in Political Reporters’ Interactivity on Twitter. Journalism Studies 20, 2 (2019), 232–247. https://doi.org/10.1080/1461670X.2017.1364140 [14] Ashiqur R. KhudaBukhsh Kunal Khadilkar and Tom M. Mitchell. 2022. Gender Bias, Social Bias, and Representation in Bollywood and Hollywood. Patterns 3, 4 (2022), 100486. https://doi.org/10.1016/j.patter.2022.100486 [15] MingYu (Ethen) Liu. 2023. Topic Modeling. https://ethen8181.github.io/machine-learning/clustering/topic_model/LDA.html. [16] J. Nathan Matias, Sarah Szalavitz, and Ethan Zuckerman. 2017. FollowBias: Supporting Behavior Change toward Gender Equality by Networked Gatekeepers on Social Media (CSCW ’17). 1082–1095. https://doi.org/10.1145/2998181.2998287 [17] Lindsey Meeks. 2016. Gendered Styles, Gendered Differences: Candidates’ Use of Personalization and Interactivity on Twitter. Journal of Information Technology & Politics 13, 4 (2016), 295–310. https://doi.org/10.1080/19331681.2016.1160268 [18] Armin Mertens, Franziska Pradel, Ayjeren Rozyjumayeva, and Jens Wäckerle. 2019. As the Tweet, so the Reply? Gender Bias in Digital Communication with Politicians. In Proceedings of the 10th ACM Conference on Web Science (WebSci ’19). 193–201. [19] Sebo P. 2021. Using genderize.io to infer the gender of first names: how to improve the accuracy of the inference. J Med Libr Assoc. (2021). [20] Anmol Panda, A’ndre Gonawela, Sreangsu Acharyya, Dibyendu Mishra, Mugdha Mohapatra, Ramgopal Chandrasekaran, and Joyojeet Pal. 2020. NivaDuck - A Scalable Pipeline to Build a Database of Political Twitter Handles for India and the United States. In International Conference on Social Media and Society. 200–209. [21] John H. Parmelee. 2013. Political Journalists and Twitter: Influences on Norms and Practices. Journal of Media Practice 14, 4 (2013), 291–305. https://doi.org/10.1386/jmpr.14.4.291_1 [22] Pallavi Prasad. 2020. One in Every Seven Tweets About Indian Women Politicians Is Abusive: Study. https://www.theswaddle.com/women-politicians-india-twitter-trolls. [23] Gazal Shekhawat, Parantak Singh, Rynaa Grover, Saloni Dash, Himani Negi, Ankur Sharma, Somya Sagarika, and Joyojeet Pal. 2021. Twitter Use by Politicians Across States in India. [24] Carole Spary. 2007. Female Political Leadership in India. Commonwealth & Comparative Politics 45, 3 (2007), 253–277. https://doi.org/10.1080/14662040701516821 [25] Genderize team. 2023. Genderize. https://genderize.io/. [26] Jesse Holcomb Usher, Nikki and Justin Littman. 2018. Twitter Makes It Worse: Political Journalists, Gendered Echo Chambers, and the Amplification of Gender Bias. The International Journal of Press/Politics 23, 3 (2018), 324–344. https://doi.org/10.1177/1940161218781254 [27] Jason Gainous Wagner, Kevin M. and Mirya R. Holman. 2017. I Am Woman, Hear Me Tweet! Gender Differences in Twitter Use among Congressional Candidates. Journal of Women, Politics & Policy 38, 4 (2017), 430–455. https://doi.org/10.1080/1554477X.2016.1268871 This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. Authors: (1) Brisha Jain, Independent researcher India and brishajain02@gmail.com; (2) Mainack Mondal, IIT Kharagpur India and mainack@cse.iitkgp.ac.in. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. Authors: Authors: (1) Brisha Jain, Independent researcher India and brishajain02@gmail.com; (2) Mainack Mondal, IIT Kharagpur India and mainack@cse.iitkgp.ac.in. Table of Links Abstract and Intro Related Work Data Collection Analysis Methodology Results Limitations Concluding Discussion References Abstract and Intro Abstract and Intro Related Work Related Work Data Collection Data Collection Analysis Methodology Analysis Methodology Results Results Limitations Limitations Concluding Discussion Concluding Discussion References References REFERENCES [1] Toril Aalberg and Anders Todal Jenssen. 2017. Gender Stereotyping of Political Candidates. Nordicom Review 28, 1 (2017), 17–32. https://doi.org/10.1515/nor-2017-0198 [2] Pushkal Agarwal, Nishanth Sastry, and Edward Wood. 2019. Tweeting MPs: Digital Engagement between Citizens and Members of Parliament in the UK. Proceedings of the International AAAI Conference on Web and Social Media 13, 01. [3] Arshia Arya, Soham De, Dibyendu Mishra, Gazal Shekhawat, Ankur Sharma, Anmol Panda, Faisal M Lalani, Parantak Singh, Ramaravind Kommiya Mothilal, Rynaa Grover, Sachita Nishal, Saloni Dash, Shehla Rashid Shora, Syeda Zainab Akbar, and Joyojeet Pal. 2022. DISMISS: Database of Indian Social Media Influencers on Twitter. [4] Nichole M. Bauer. 2015. Emotional, Sensitive, and Unfit for Office? Gender Stereotype Activation and Support Female Candidates. Political Psychology 36, 6 (2015), 691–708. [5] Aditi Bhowmick, Paul Novosad, Sam Asher, Elliott Ash, Bilal Siddiqi, Christoph Goessmann, Daniel Chen, and Tanaya Devi. 2021. In-Group Bias in the Indian Judiciary: Evidence from 5.5 Million Criminal Cases. In Proceedings of the 4th ACM SIGCAS Conference on Computing and Sustainable Societies (COMPASS ’21). 47. https://doi.org/10.1145/3460112.3471943 https://doi.org/10.1145/3460112.3471943 [6] Jose Camacho-Collados, Kiamehr Rezaee, Talayeh Riahi, Asahi Ushio, Daniel Loureiro, Dimosthenis Antypas, Joanne Boisson, Luis Espinosa-Anke, Fangyu Liu, Eugenio Martínez-Cámara, et al. 2022. TweetNLP: Cutting-Edge Natural Language Processing for Social Media. In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing: System Demonstrations. [7] Tessa M. Ditonto, Allison J. Hamilton, and David P. Redlawsk. 2014. Gender Stereotypes, Information Search, and Voting Behavior in Political Campaigns. Political Behavior 36, 2 (2014), 335–358. https://doi.org/10.1007/s11109-013-9232-6 https://doi.org/10.1007/s11109-013-9232-6 [8] Kathleen Dolan and Timothy Lynch. 2014. It Takes a Survey: Understanding Gender Stereotypes, Abstract Attitudes, and Voting for Women Candidates. American Politics Research 42, 4 (2014), 656–576. https://doi.org/10.1177/1532673X13503034 https://doi.org/10.1177/1532673X13503034 [9] Heather Evans. 2016. Do Women Only Talk about ‘Female Issues’? Gender and
Issue Discussion on Twitter. Online Information Review 40, 5 (2016), 660–672. https://doi.org/10.1108/OIR-10-2015-0338 https://doi.org/10.1108/OIR-10-2015-0338 [10] Heather K. Evans and Jennifer Hayes Clark. 2016. You Tweet Like a Girl!’: How Female Candidates Campaign on Twitter. American Politics Research 44, 2 (2016), 326–352. https://doi.org/10.1177/1532673X15597747 https://doi.org/10.1177/1532673X15597747 [11] Peter A. Gloor, Joao Marcos, Patrick M. de Boer, Hauke Fuehres, Wei Lo, and Keiichi Nemoto. 2015. Cultural Anthropology through the Lens of Wikipedia: Historical Leader Networks, Gender Bias, and News-based Sentiment. arXiv:1508.00055 [ cs.CY ] https://doi.org/10.48550/ARXIV.1508.00055 cs.CY https://doi.org/10.48550/ARXIV.1508.00055 [12] Leonie Huddy and Nayda Terkildsen. 1993. Gender Stereotypes and the Perception of Male and Female Candidates. American Journal of Political Science 37, 1 (1993), 119. https://doi.org/10.2307/2111526 https://doi.org/10.2307/2111526 [13] Berrin Beasley John H. Parmelee, Nataliya Roman and Stephynie C. Perkins. 2019. Gender and Generational Differences in Political Reporters’ Interactivity on Twitter. Journalism Studies 20, 2 (2019), 232–247. https://doi.org/10.1080/1461670X.2017.1364140 https://doi.org/10.1080/1461670X.2017.1364140 [14] Ashiqur R. KhudaBukhsh Kunal Khadilkar and Tom M. Mitchell. 2022. Gender Bias, Social Bias, and Representation in Bollywood and Hollywood. Patterns 3, 4 (2022), 100486. https://doi.org/10.1016/j.patter.2022.100486 https://doi.org/10.1016/j.patter.2022.100486 [15] MingYu (Ethen) Liu. 2023. Topic Modeling. https://ethen8181.github.io/machine-learning/clustering/topic_model/LDA.html . https://ethen8181.github.io/machine-learning/clustering/topic_model/LDA.html [16] J. Nathan Matias, Sarah Szalavitz, and Ethan Zuckerman. 2017. FollowBias: Supporting Behavior Change toward Gender Equality by Networked Gatekeepers on Social Media (CSCW ’17). 1082–1095. https://doi.org/10.1145/2998181.2998287 https://doi.org/10.1145/2998181.2998287 [17] Lindsey Meeks. 2016. Gendered Styles, Gendered Differences: Candidates’ Use of Personalization and Interactivity on Twitter. Journal of Information Technology & Politics 13, 4 (2016), 295–310. https://doi.org/10.1080/19331681.2016.1160268 https://doi.org/10.1080/19331681.2016.1160268 [18] Armin Mertens, Franziska Pradel, Ayjeren Rozyjumayeva, and Jens Wäckerle. 2019. As the Tweet, so the Reply? Gender Bias in Digital Communication with Politicians. In Proceedings of the 10th ACM Conference on Web Science (WebSci ’19). 193–201. [19] Sebo P. 2021. Using genderize.io to infer the gender of first names: how to improve the accuracy of the inference. J Med Libr Assoc. (2021). genderize.io [20] Anmol Panda, A’ndre Gonawela, Sreangsu Acharyya, Dibyendu Mishra, Mugdha Mohapatra, Ramgopal Chandrasekaran, and Joyojeet Pal. 2020. NivaDuck - A Scalable Pipeline to Build a Database of Political Twitter Handles for India and the United States. In International Conference on Social Media and Society. 200–209. [21] John H. Parmelee. 2013. Political Journalists and Twitter: Influences on Norms and Practices. Journal of Media Practice 14, 4 (2013), 291–305. https://doi.org/10.1386/jmpr.14.4.291_1 https://doi.org/10.1386/jmpr.14.4.291_1 [22] Pallavi Prasad. 2020. One in Every Seven Tweets About Indian Women Politicians Is Abusive: Study. https://www.theswaddle.com/women-politicians-india-twitter-trolls . https://www.theswaddle.com/women-politicians-india-twitter-trolls [23] Gazal Shekhawat, Parantak Singh, Rynaa Grover, Saloni Dash, Himani Negi, Ankur Sharma, Somya Sagarika, and Joyojeet Pal. 2021. Twitter Use by Politicians Across States in India. [24] Carole Spary. 2007. Female Political Leadership in India. Commonwealth & Comparative Politics 45, 3 (2007), 253–277. https://doi.org/10.1080/14662040701516821 https://doi.org/10.1080/14662040701516821 [25] Genderize team. 2023. Genderize. https://genderize.io/ . https://genderize.io/ [26] Jesse Holcomb Usher, Nikki and Justin Littman. 2018. Twitter Makes It Worse: Political Journalists, Gendered Echo Chambers, and the Amplification of Gender Bias. The International Journal of Press/Politics 23, 3 (2018), 324–344. https://doi.org/10.1177/1940161218781254 https://doi.org/10.1177/1940161218781254 [27] Jason Gainous Wagner, Kevin M. and Mirya R. Holman. 2017. I Am Woman, Hear Me Tweet! Gender Differences in Twitter Use among Congressional Candidates. Journal of Women, Politics & Policy 38, 4 (2017), 430–455. https://doi.org/10.1080/1554477X.2016.1268871 https://doi.org/10.1080/1554477X.2016.1268871

Uncovering Gender Bias within Journalist-Politician Interaction in Indian Twitter: References

ভারতীয় টুইটারে সাংবাদিক-রাজনীতিবিদ ইন্টারঅ্যাকশনের মধ্যে জেন্ডার বায়াস উন্মোচন: রেফারেন্স

Aufdeckung geschlechtsspezifischer Voreingenommenheit in der Interaktion zwischen Journalisten und Politikern im indischen Twitter: Referenzen

Descubriendo el sesgo de género en la interacción entre periodistas y políticos en Twitter indio: referencias

Découvrir les préjugés sexistes dans les interactions journalistes-hommes politiques sur Twitter indien : références

भारतीय ट्विटर पर पत्रकार-राजनेता बातचीत में लैंगिक पूर्वाग्रह को उजागर करना: संदर्भ

インドのツイッターにおけるジャーナリストと政治家の交流におけるジェンダーバイアスの解明：参考文献

인도 트위터의 언론인-정치인 상호작용에서 성 편견 발견: 참고자료

Descobrindo o preconceito de gênero na interação jornalista-político no Twitter indiano: referências

Выявление гендерных предубеждений во взаимодействии журналистов и политиков в индийском Твиттере: ссылки

Hint Twitter'ında Gazeteci-Siyasetçi Etkileşiminde Cinsiyet Önyargısını Ortaya Çıkarmak: Referanslar

Khám phá sự thiên vị giới tính trong tương tác giữa nhà báo và chính trị gia trên Twitter của Ấn Độ: Tài liệu tham khảo

揭示印度推特上记者与政客互动中的性别偏见：参考文献

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Xiaofei Sun, Zhejiang University & xiaofei_sun@zju.edu.cn;
(2) Xiaoya Li, Shannon.AI, Bytedance & xiaoya_li@shannonai.com;
(3) Shengyu Zhang, Zhejiang University & sy_zhang@zju.edu.cn;
(4) Shuhe Wang, Peking University & wangshuhe@stu.pku.edu.cn;
(5) Fei Wu, Zhejiang University & wufei@zju.edu.cn;
(6) Jiwei Li, Zhejiang University &  jiwei_li@zju.edu.cn;
(7) Tianwei Zhang, Nanyang Technological University & tianwei.zhang@ntu.edu.sg;
(8) Guoyin Wang, Bytedance & guoyin.wang@bytedance.com. Table of Links Abstract and Introduction
Related Work
LLM Negotiation for Sentiment Analysis
Experiments
Ablation Studies
Conclusion and References 5 Ablation Studies In this section, we perform ablation studies on the Twitter dataset to better understand the mechanism behind the negotiation framework. 5.1 Who takes which role matters In the negotiation framework, there are two roles, the generator and the discriminator, which two separate LLMs take. Table 2 shows the performance for setups where GPT-3.5 and GPT-4 take different roles. As can be seen, when GPT-3.5 acts as the generator, and GPT-4 acts as the discriminator (G3.5-D4 for short), the performance (68.8) is better than single GPT-3.5 without negotiation (65.2), but worse than single GPT-4 without negotiation (69.5). In contrast, negotiation-based configurations with GPT-4 acting as the generator (G4-D3.5 and G4-D4) consistently outperforms standalone GPT-4 or GPT-3.5 models without negotiation. These results underscore the pivotal role that the generator plays in influencing the negotiation outcome. Furthermore, we observe G4- D3.5 can beat G4-D4. We attribute such advantage to the hypothesis that utilizing heterogeneous LLMs for distinct roles could optimize the negotiation’s performance. 5.2 Consensus Percentage Table 3 consensus percentage for different setups. As can be seen, when GPT-4 acts as the generator, the negotiation is more likely to reach a consensus, or reach a consensus in fewer turns. The explanation is intuitive: for the twitter task, we can see from table 1 that GPT-4 obtains better performances that GPT-3.5, which means the reasoning process for GPT-4 is more sensible than 3.5, making the decision of the former more likely to be agreed on. 5.3 Effect of the Reasoning Process In the negotiation process, LLMs are asked to articulate the reason process, a strategy akin to CoT(Wei et al., 2022b). We examine the importance for listing reasons in negotiation by removing the reasoning process and asking LLMs to only output decisions. Results are shown in Table 4. As can be seen, for the three setups, single GPT-3.5, where only GPT-3.5 is used without negotiation, single GPT-4, where only GPT-4 is used without negotiation, and GPT-3.5+GPT-4 where negotiation is employed, performances all degrade when the reasoning process is removed. But interestingly, we see a greater degrade (-2.3) for the negotiation than the single model setup (-1.2 for single-GPT-3.5 and -0.9 for single-GPT-4). This is in accord with our expectation as the reasoning process is of greater significance in the negotiation setup. This paper is available on arxiv under CC 4.0 license. Authors: (1) Xiaofei Sun, Zhejiang University & xiaofei_sun@zju.edu.cn; (2) Xiaoya Li, Shannon.AI, Bytedance & xiaoya_li@shannonai.com; (3) Shengyu Zhang, Zhejiang University & sy_zhang@zju.edu.cn; (4) Shuhe Wang, Peking University & wangshuhe@stu.pku.edu.cn; (5) Fei Wu, Zhejiang University & wufei@zju.edu.cn; (6) Jiwei Li, Zhejiang University &  jiwei_li@zju.edu.cn; (7) Tianwei Zhang, Nanyang Technological University & tianwei.zhang@ntu.edu.sg; (8) Guoyin Wang, Bytedance & guoyin.wang@bytedance.com. This paper is available on arxiv under CC 4.0 license. Authors: (1) Xiaofei Sun, Zhejiang University & xiaofei_sun@zju.edu.cn; (2) Xiaoya Li, Shannon.AI, Bytedance & xiaoya_li@shannonai.com; (3) Shengyu Zhang, Zhejiang University & sy_zhang@zju.edu.cn; (4) Shuhe Wang, Peking University & wangshuhe@stu.pku.edu.cn; (5) Fei Wu, Zhejiang University & wufei@zju.edu.cn; (6) Jiwei Li, Zhejiang University &  jiwei_li@zju.edu.cn; (7) Tianwei Zhang, Nanyang Technological University & tianwei.zhang@ntu.edu.sg; (8) Guoyin Wang, Bytedance & guoyin.wang@bytedance.com. Table of Links Abstract and Introduction Related Work LLM Negotiation for Sentiment Analysis Experiments Ablation Studies Conclusion and References Abstract and Introduction Abstract and Introduction Related Work Related Work LLM Negotiation for Sentiment Analysis LLM Negotiation for Sentiment Analysis Experiments Experiments Ablation Studies Ablation Studies Conclusion and References Conclusion and References 5 Ablation Studies In this section, we perform ablation studies on the Twitter dataset to better understand the mechanism behind the negotiation framework. 5.1 Who takes which role matters In the negotiation framework, there are two roles, the generator and the discriminator, which two separate LLMs take. Table 2 shows the performance for setups where GPT-3.5 and GPT-4 take different roles. As can be seen, when GPT-3.5 acts as the generator, and GPT-4 acts as the discriminator (G3.5-D4 for short), the performance (68.8) is better than single GPT-3.5 without negotiation (65.2), but worse than single GPT-4 without negotiation (69.5). In contrast, negotiation-based configurations with GPT-4 acting as the generator (G4-D3.5 and G4-D4) consistently outperforms standalone GPT-4 or GPT-3.5 models without negotiation. These results underscore the pivotal role that the generator plays in influencing the negotiation outcome. Furthermore, we observe G4- D3.5 can beat G4-D4. We attribute such advantage to the hypothesis that utilizing heterogeneous LLMs for distinct roles could optimize the negotiation’s performance. 5.2 Consensus Percentage Table 3 consensus percentage for different setups. As can be seen, when GPT-4 acts as the generator, the negotiation is more likely to reach a consensus, or reach a consensus in fewer turns. The explanation is intuitive: for the twitter task, we can see from table 1 that GPT-4 obtains better performances that GPT-3.5, which means the reasoning process for GPT-4 is more sensible than 3.5, making the decision of the former more likely to be agreed on. 5.3 Effect of the Reasoning Process In the negotiation process, LLMs are asked to articulate the reason process, a strategy akin to CoT(Wei et al., 2022b). We examine the importance for listing reasons in negotiation by removing the reasoning process and asking LLMs to only output decisions. Results are shown in Table 4. As can be seen, for the three setups, single GPT-3.5, where only GPT-3.5 is used without negotiation, single GPT-4, where only GPT-4 is used without negotiation, and GPT-3.5+GPT-4 where negotiation is employed, performances all degrade when the reasoning process is removed. But interestingly, we see a greater degrade (-2.3) for the negotiation than the single model setup (-1.2 for single-GPT-3.5 and -0.9 for single-GPT-4). This is in accord with our expectation as the reasoning process is of greater significance in the negotiation setup.

Sentiment Analysis through LLM Negotiations: Ablation Studies

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Xiaofei Sun, Zhejiang University & xiaofei_sun@zju.edu.cn;
(2) Xiaoya Li, Shannon.AI, Bytedance & xiaoya_li@shannonai.com;
(3) Shengyu Zhang, Zhejiang University & sy_zhang@zju.edu.cn;
(4) Shuhe Wang, Peking University & wangshuhe@stu.pku.edu.cn;
(5) Fei Wu, Zhejiang University & wufei@zju.edu.cn;
(6) Jiwei Li, Zhejiang University &  jiwei_li@zju.edu.cn;
(7) Tianwei Zhang, Nanyang Technological University & tianwei.zhang@ntu.edu.sg;
(8) Guoyin Wang, Bytedance & guoyin.wang@bytedance.com. Table of Links Abstract and Introduction
Related Work
LLM Negotiation for Sentiment Analysis
Experiments
Ablation Studies
Conclusion and References 3 LLM Negotiation for Sentiment Analysis 3.1 Overview In this section, we detail the multi-LLM negotiation framework for sentiment analysis: Two LLMs perform as the answer generator and discriminator. We refer to the interaction between the generator and the discriminator as a negotiation. The negotiation will repeat until a consensus is reached or the maximum number of negotiation turns is exceeded. Illustrations are shown in Figures 1 and 2. 3.2 Reasoning-infused generator The generator is backboned by a large language model. We ask the answer generator based on the ICL paradigm through prompts, aiming to generate a step-by-step reasoning chain and a decision towards the sentiment polarity of the test input. Prompts are composed of three elements: a task description, demonstrations, and a test input.  The task description is a description of the task in natural language (e.g., "Please determine the overall sentiment of test input."); the test input is the textual input in the test set (e.g., "The sky is blue."); demonstrations are from the train set of the task. Each consists of three elements: input, reasoning chains, and sentimental decision. For each test input, we first retrieve K nearest neighbors (input, sentiment decision) from the train set as demonstrations. Then, we transform demonstrations to (input, reasoning process, sentiment decision) triplets by prompting the generator to produce a reasoning chain. After concatenating the task description, demonstrations, and the test input, we forward the prompt to the generator, which will respond with a step-by-step reasoning chain and a sentimental decision. 3.3 Explanation-deriving discriminator The discriminator is backboned by another LLM. After finishing the answer generating process, the answer discriminator is used to judge whether the decision made by the generator is correct and provide a reasonable explanation. To accomplish this goal, we first construct prompts for the answer discriminator. The prompt is composed of four elements: a task description, demonstrations, a test input, and the response from the answer generator. The task description is a piece of text that describes the task in natural language (e.g., "Please determine whether the decision is correct."). Each demonstration is composed of six elements: (input text, a reasoning chain, sentiment decision, discriminator attitude, discriminator explanations, discriminator decision) and constructed by prompting the answer discriminator to provide explanations of why the sentiment decision is correct for the input text. Then we ask the discriminator with the construct prompt. The answer discriminator will respond with a text string, containing an attitude (i.e., yes, no) that denotes whether the discriminator agrees with the generator, explanations that explain why the discriminator agrees/disagrees with the generator, and a discriminator decision that determines the sentiment of the test input. Why Two LLMs but Not One? There are two reasons for using two different LLMs separately for the generator and the discriminator rather than using a single LLM to act as two roles: (1) If an LLM makes a mistake as a generator due to incorrect reasoning, it is more likely that it will also make the same mistake as the discriminator as since generator and the discriminator from the same model are very likely to make similar rationales; (2) by using two separate models, we are able to take the advantage of the complementary abilities of the two models. 3.4 Role-flipped Negotiation After two LLMs end with a negotiation, we ask them flip roles and initiate a new negotiation, where the second LLM acts as the generator, and the first LLM acts as the discriminator. We refer the interaction of two LLMs with flipped roles as role-flipped negotiation. Likewise, the role flipped negotiation is ended until a consensus is reached or the maximum number of negotiation turns is exceeded. When both negotiations result in an agreement and their decisions are the same, we can choose either decision as the final one since they are the same. If one of the negotiations fails to reach a consensus while the other reaches a decision, we choose the decision from the negotiation  that reached a consensus as the final decision. However, if both negotiations reach a consensus but their decisions do not align, we will require the assistance of an additional Language Model (LLM), as will be explained in more detail below." Introducing a third LLM If the decision from the two negotiations do not align, we introduce a third LLM and conduct the negotiation and role-flipped negotiation with each of the two aforementioned LLMs. Subsequently, we will get 6 negotiation results and vote on these results: the decision that appears most frequently is taken as the sentiment polarity of the input test. This paper is available on arxiv under CC 4.0 license. Authors: (1) Xiaofei Sun, Zhejiang University & xiaofei_sun@zju.edu.cn; (2) Xiaoya Li, Shannon.AI, Bytedance & xiaoya_li@shannonai.com; (3) Shengyu Zhang, Zhejiang University & sy_zhang@zju.edu.cn; (4) Shuhe Wang, Peking University & wangshuhe@stu.pku.edu.cn; (5) Fei Wu, Zhejiang University & wufei@zju.edu.cn; (6) Jiwei Li, Zhejiang University &  jiwei_li@zju.edu.cn; (7) Tianwei Zhang, Nanyang Technological University & tianwei.zhang@ntu.edu.sg; (8) Guoyin Wang, Bytedance & guoyin.wang@bytedance.com. This paper is available on arxiv under CC 4.0 license. Authors: (1) Xiaofei Sun, Zhejiang University & xiaofei_sun@zju.edu.cn; (2) Xiaoya Li, Shannon.AI, Bytedance & xiaoya_li@shannonai.com; (3) Shengyu Zhang, Zhejiang University & sy_zhang@zju.edu.cn; (4) Shuhe Wang, Peking University & wangshuhe@stu.pku.edu.cn; (5) Fei Wu, Zhejiang University & wufei@zju.edu.cn; (6) Jiwei Li, Zhejiang University &  jiwei_li@zju.edu.cn; (7) Tianwei Zhang, Nanyang Technological University & tianwei.zhang@ntu.edu.sg; (8) Guoyin Wang, Bytedance & guoyin.wang@bytedance.com. Table of Links Abstract and Introduction Related Work LLM Negotiation for Sentiment Analysis Experiments Ablation Studies Conclusion and References Abstract and Introduction Abstract and Introduction Related Work Related Work LLM Negotiation for Sentiment Analysis LLM Negotiation for Sentiment Analysis Experiments Experiments Ablation Studies Ablation Studies Conclusion and References Conclusion and References 3 LLM Negotiation for Sentiment Analysis 3.1 Overview In this section, we detail the multi-LLM negotiation framework for sentiment analysis: Two LLMs perform as the answer generator and discriminator. We refer to the interaction between the generator and the discriminator as a negotiation. The negotiation will repeat until a consensus is reached or the maximum number of negotiation turns is exceeded. Illustrations are shown in Figures 1 and 2. 3.2 Reasoning-infused generator The generator is backboned by a large language model. We ask the answer generator based on the ICL paradigm through prompts, aiming to generate a step-by-step reasoning chain and a decision towards the sentiment polarity of the test input. Prompts are composed of three elements: a task description, demonstrations, and a test input.  The task description is a description of the task in natural language (e.g., "Please determine the overall sentiment of test input."); the test input is the textual input in the test set (e.g., "The sky is blue."); demonstrations are from the train set of the task. Each consists of three elements: input, reasoning chains, and sentimental decision. For each test input, we first retrieve K nearest neighbors (input, sentiment decision) from the train set as demonstrations. Then, we transform demonstrations to (input, reasoning process, sentiment decision) triplets by prompting the generator to produce a reasoning chain. After concatenating the task description, demonstrations, and the test input, we forward the prompt to the generator, which will respond with a step-by-step reasoning chain and a sentimental decision. 3.3 Explanation-deriving discriminator The discriminator is backboned by another LLM. After finishing the answer generating process, the answer discriminator is used to judge whether the decision made by the generator is correct and provide a reasonable explanation. To accomplish this goal, we first construct prompts for the answer discriminator. The prompt is composed of four elements: a task description, demonstrations, a test input, and the response from the answer generator. The task description is a piece of text that describes the task in natural language (e.g., "Please determine whether the decision is correct."). Each demonstration is composed of six elements: (input text, a reasoning chain, sentiment decision, discriminator attitude, discriminator explanations, discriminator decision) and constructed by prompting the answer discriminator to provide explanations of why the sentiment decision is correct for the input text. Then we ask the discriminator with the construct prompt. The answer discriminator will respond with a text string, containing an attitude (i.e., yes, no) that denotes whether the discriminator agrees with the generator, explanations that explain why the discriminator agrees/disagrees with the generator, and a discriminator decision that determines the sentiment of the test input. Why Two LLMs but Not One? There are two reasons for using two different LLMs separately for the generator and the discriminator rather than using a single LLM to act as two roles: (1) If an LLM makes a mistake as a generator due to incorrect reasoning, it is more likely that it will also make the same mistake as the discriminator as since generator and the discriminator from the same model are very likely to make similar rationales; (2) by using two separate models, we are able to take the advantage of the complementary abilities of the two models. Why Two LLMs but Not One? 3.4 Role-flipped Negotiation After two LLMs end with a negotiation, we ask them flip roles and initiate a new negotiation, where the second LLM acts as the generator, and the first LLM acts as the discriminator. We refer the interaction of two LLMs with flipped roles as role-flipped negotiation. Likewise, the role flipped negotiation is ended until a consensus is reached or the maximum number of negotiation turns is exceeded. When both negotiations result in an agreement and their decisions are the same, we can choose either decision as the final one since they are the same. If one of the negotiations fails to reach a consensus while the other reaches a decision, we choose the decision from the negotiation  that reached a consensus as the final decision. However, if both negotiations reach a consensus but their decisions do not align, we will require the assistance of an additional Language Model (LLM), as will be explained in more detail below." Introducing a third LLM If the decision from the two negotiations do not align, we introduce a third LLM and conduct the negotiation and role-flipped negotiation with each of the two aforementioned LLMs. Subsequently, we will get 6 negotiation results and vote on these results: the decision that appears most frequently is taken as the sentiment polarity of the input test. Introducing a third LLM

Sentiment Analysis through LLM Negotiations: LLM Negotiation for Sentiment Analysis

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Xiaofei Sun, Zhejiang University & xiaofei_sun@zju.edu.cn;
(2) Xiaoya Li, Shannon.AI, Bytedance & xiaoya_li@shannonai.com;
(3) Shengyu Zhang, Zhejiang University & sy_zhang@zju.edu.cn;
(4) Shuhe Wang, Peking University & wangshuhe@stu.pku.edu.cn;
(5) Fei Wu, Zhejiang University & wufei@zju.edu.cn;
(6) Jiwei Li, Zhejiang University &  jiwei_li@zju.edu.cn;
(7) Tianwei Zhang, Nanyang Technological University & tianwei.zhang@ntu.edu.sg;
(8) Guoyin Wang, Bytedance & guoyin.wang@bytedance.com. Table of Links Abstract and Introduction
Related Work
LLM Negotiation for Sentiment Analysis
Experiments
Ablation Studies
Conclusion and References 2 Related Work 2.1 Sentiment Analysis Sentiment analysis (Pang and Lee, 2008; Go et al., 2009; Maas et al., 2011a; Zhang and Liu, 2012; Baccianella et al., 2010; Medhat et al., 2014; Bakshi et al., 2016; Zhang et al., 2018) is a task that aims to determine the overall sentiment polarity (e.g., positive, negative, neutral) of a given text. Earlier work often formalized the task as a two-step problem: (1) extract features using RNNs (Socher et al., 2013; Qian et al., 2016; Peled and Reichart, 2017; Wang et al., 2016b; Guggilla et al., 2016; Vo and Zhang, 2015), CNNs (Kalchbrenner et al., 2014; Wang et al., 2016a; Guan et al., 2016; Yu and Jiang, 2016; Mishra et al., 2017), pretrained language models (Lin et al., 2021; Sun et al., 2021; Phan and Ogunbona, 2020; Dai et al., 2021), etc; and (2) feed extracted features into a classifier for obtaining a pre-defined sentimental label. In recent years, in-context learning (ICL) has achieved great success and changed the paradigm of NLP tasks. Many works adapt ICL to the sentiment analysis task: Qin et al. (2023b); Sun et al.(2023a) propose a series of strategies to improve ChatGPT’s performance on the sentiment analysis task; Fei et al. (2023) propose a threehop reasoning framework, which induces the implicit aspect, opinion, and finally the sentiment polarity for the implicit sentiment analysis task;ƒ Zhang et al. (2023d) find that LLMs can achieve satisfactory performance on the binary sentiment classification task, but they underperform to the supervised baseline on more complex tasks (e.g., fine-grained sentiment analysis) that require deeper understanding or structured sentiment information. 2.2 Large Language Models and In-context Learning Large language models (LLMs) (Wang et al., 2022a; Zhang et al., 2023b) are models trained on massive unlabeled text corpora with self supervised learning techniques. Based on the model architecture, LLMs can be categorized into three types: (1) encoder-only models, which contain a text encoder and generate the input representations, such as BERT (Devlin et al., 2018) and its variants (Lan et al., 2019; Liu et al., 2019; Sun et al., 2020; Clark et al., 2020; Feng et al., 2020; Joshi et al., 2020; Sun et al., 2020, 2021); (2) decoder-only models, which have a decoder and generate text conditioned on the input text like GPT-series models (Radford et al., 2019; Brown et al., 2020; Keskar et al., 2019; Radford et al., 2019; Chowdhery et al., 2022; Ouyang et al., 2022; Zhang et al., 2022a; Scao et al., 2022; Zeng et al., 2022b; Touvron et al., 2023a; Peng et al., 2023; OpenAI, 2023); and (3) encoder-decoder models, which have a pair of encoder-decoder and generate text conditioned on the input representation, such as T5 (Raffel et al., 2020) and its variants (Lewis et al., 2019; Xue et al., 2020). Starting with GPT-3 (Brown et al., 2020), LLMs have shown emerging capabilities (Wei et al., 2022a) and completed NLP tasks through incontext learning (ICL), where LLMs generate labelintensive text conditioned on a few annotated examples without gradient updates. Many studies in the literature propose strategies for improving ICL performances on NLP tasks. Li and Liang (2021); Chevalier et al. (2023); Mu et al. (2023) optimize prompts in the continuous space. Liu et al. (2021a); Wan et al. (2023); Zhang et al. (2023a) search through the train set to retrieve k nearest neighbors of a test input as demonstrations. Zhang et al. (2022b); Sun et al. (2023b); Yao et al (2023) decompose a task into a few subtasks and solve them step-by-step towards the final answer conditioned on LLM-generated reasoning chains. Sun et al. (2023a); Wang et al. (2023) propose to verify LLMs’ results by conducting a new round of prompting; Liu et al. (2021b); Feng et al. (2023) use LLMs to generate natural language knowledge statements and integrate external knowledge statements into prompts. 2.3 The LLM collaboration The LLM collaboration involves multiple LLMs working together to solve a given task. Specifically, the task is decomposed to several intermediate tasks, and each LLM is assigned to complete one intermediate task independently. The given task is solved after integrating or summarizing these intermediate results. The LLM collaboration approach can exploit the capabilities of LLMs, improve performances on complex tasks and enable to build complicated systems. Shinn et al. (2023); Sun et al. (2023a); Gero et al. (2023); Wang and Li (2023); Chen et al. (2023b) construct auxiliary tasks (e.g., reflection, verification tasks) and revise the response to the original task referring to the result of the auxiliary task. Talebirad and Nadiri (2023); Hong et al. (2023); Qian et al. (2023) assign characterize profiles (e.g., project manager, software engineer) to LLMs and gain performance boosts on character-specific tasks through behavior animations. Li et al. (2022); Zeng et al. (2022a); Chen et al. (2023a); Du et al. (2023); Liang et al. (2023) use a debate strategy in which multiple different LLMs propose their own responses to the given task and debate over multiple turns until getting a common final answer. Besides, Shen et al. (2023); Gao et al. (2023); Ge et al. (2023); Zhang et al. (2023c); Hao et al. (2023) employone LLM as the task controller, which devises a  plan for the given task, selects expert models for implementation and summarizes the responses of intermediate planned tasks. Other LLMs serve as task executors, completing intermediate tasks in their areas of expertise. This paper is available on arxiv under CC 4.0 license. Authors: (1) Xiaofei Sun, Zhejiang University & xiaofei_sun@zju.edu.cn; (2) Xiaoya Li, Shannon.AI, Bytedance & xiaoya_li@shannonai.com; (3) Shengyu Zhang, Zhejiang University & sy_zhang@zju.edu.cn; (4) Shuhe Wang, Peking University & wangshuhe@stu.pku.edu.cn; (5) Fei Wu, Zhejiang University & wufei@zju.edu.cn; (6) Jiwei Li, Zhejiang University &  jiwei_li@zju.edu.cn; (7) Tianwei Zhang, Nanyang Technological University & tianwei.zhang@ntu.edu.sg; (8) Guoyin Wang, Bytedance & guoyin.wang@bytedance.com. This paper is available on arxiv under CC 4.0 license. Authors: (1) Xiaofei Sun, Zhejiang University & xiaofei_sun@zju.edu.cn; (2) Xiaoya Li, Shannon.AI, Bytedance & xiaoya_li@shannonai.com; (3) Shengyu Zhang, Zhejiang University & sy_zhang@zju.edu.cn; (4) Shuhe Wang, Peking University & wangshuhe@stu.pku.edu.cn; (5) Fei Wu, Zhejiang University & wufei@zju.edu.cn; (6) Jiwei Li, Zhejiang University &  jiwei_li@zju.edu.cn; (7) Tianwei Zhang, Nanyang Technological University & tianwei.zhang@ntu.edu.sg; (8) Guoyin Wang, Bytedance & guoyin.wang@bytedance.com. Table of Links Abstract and Introduction Related Work LLM Negotiation for Sentiment Analysis Experiments Ablation Studies Conclusion and References Abstract and Introduction Abstract and Introduction Related Work Related Work LLM Negotiation for Sentiment Analysis LLM Negotiation for Sentiment Analysis Experiments Experiments Ablation Studies Ablation Studies Conclusion and References Conclusion and References 2 Related Work 2.1 Sentiment Analysis Sentiment analysis (Pang and Lee, 2008; Go et al., 2009; Maas et al., 2011a; Zhang and Liu, 2012; Baccianella et al., 2010; Medhat et al., 2014; Bakshi et al., 2016; Zhang et al., 2018) is a task that aims to determine the overall sentiment polarity (e.g., positive, negative, neutral) of a given text. Earlier work often formalized the task as a two-step problem: (1) extract features using RNNs (Socher et al., 2013; Qian et al., 2016; Peled and Reichart, 2017; Wang et al., 2016b; Guggilla et al., 2016; Vo and Zhang, 2015), CNNs (Kalchbrenner et al., 2014; Wang et al., 2016a; Guan et al., 2016; Yu and Jiang, 2016; Mishra et al., 2017), pretrained language models (Lin et al., 2021; Sun et al., 2021; Phan and Ogunbona, 2020; Dai et al., 2021), etc; and (2) feed extracted features into a classifier for obtaining a pre-defined sentimental label. In recent years, in-context learning (ICL) has achieved great success and changed the paradigm of NLP tasks. Many works adapt ICL to the sentiment analysis task: Qin et al. (2023b); Sun et al.(2023a) propose a series of strategies to improve ChatGPT’s performance on the sentiment analysis task; Fei et al. (2023) propose a threehop reasoning framework, which induces the implicit aspect, opinion, and finally the sentiment polarity for the implicit sentiment analysis task;ƒ Zhang et al. (2023d) find that LLMs can achieve satisfactory performance on the binary sentiment classification task, but they underperform to the supervised baseline on more complex tasks (e.g., fine-grained sentiment analysis) that require deeper understanding or structured sentiment information. 2.2 Large Language Models and In-context Learning Large language models (LLMs) (Wang et al., 2022a; Zhang et al., 2023b) are models trained on massive unlabeled text corpora with self supervised learning techniques. Based on the model architecture, LLMs can be categorized into three types: (1) encoder-only models, which contain a text encoder and generate the input representations, such as BERT (Devlin et al., 2018) and its variants (Lan et al., 2019; Liu et al., 2019; Sun et al., 2020; Clark et al., 2020; Feng et al., 2020; Joshi et al., 2020; Sun et al., 2020, 2021); (2) decoder-only models, which have a decoder and generate text conditioned on the input text like GPT-series models (Radford et al., 2019; Brown et al., 2020; Keskar et al., 2019; Radford et al., 2019; Chowdhery et al., 2022; Ouyang et al., 2022; Zhang et al., 2022a; Scao et al., 2022; Zeng et al., 2022b; Touvron et al., 2023a; Peng et al., 2023; OpenAI, 2023); and (3) encoder-decoder models, which have a pair of encoder-decoder and generate text conditioned on the input representation, such as T5 (Raffel et al., 2020) and its variants (Lewis et al., 2019; Xue et al., 2020). Starting with GPT-3 (Brown et al., 2020), LLMs have shown emerging capabilities (Wei et al., 2022a) and completed NLP tasks through incontext learning (ICL), where LLMs generate labelintensive text conditioned on a few annotated examples without gradient updates. Many studies in the literature propose strategies for improving ICL performances on NLP tasks. Li and Liang (2021); Chevalier et al. (2023); Mu et al. (2023) optimize prompts in the continuous space. Liu et al. (2021a); Wan et al. (2023); Zhang et al. (2023a) search through the train set to retrieve k nearest neighbors of a test input as demonstrations. Zhang et al. (2022b); Sun et al. (2023b); Yao et al (2023) decompose a task into a few subtasks and solve them step-by-step towards the final answer conditioned on LLM-generated reasoning chains. Sun et al. (2023a); Wang et al. (2023) propose to verify LLMs’ results by conducting a new round of prompting; Liu et al. (2021b); Feng et al. (2023) use LLMs to generate natural language knowledge statements and integrate external knowledge statements into prompts. 2.3 The LLM collaboration The LLM collaboration involves multiple LLMs working together to solve a given task. Specifically, the task is decomposed to several intermediate tasks, and each LLM is assigned to complete one intermediate task independently. The given task is solved after integrating or summarizing these intermediate results. The LLM collaboration approach can exploit the capabilities of LLMs, improve performances on complex tasks and enable to build complicated systems. Shinn et al. (2023); Sun et al. (2023a); Gero et al. (2023); Wang and Li (2023); Chen et al. (2023b) construct auxiliary tasks (e.g., reflection, verification tasks) and revise the response to the original task referring to the result of the auxiliary task. Talebirad and Nadiri (2023); Hong et al. (2023); Qian et al. (2023) assign characterize profiles (e.g., project manager, software engineer) to LLMs and gain performance boosts on character-specific tasks through behavior animations. Li et al. (2022); Zeng et al. (2022a); Chen et al. (2023a); Du et al. (2023); Liang et al. (2023) use a debate strategy in which multiple different LLMs propose their own responses to the given task and debate over multiple turns until getting a common final answer. Besides, Shen et al. (2023); Gao et al. (2023); Ge et al. (2023); Zhang et al. (2023c); Hao et al. (2023) employone LLM as the task controller, which devises a  plan for the given task, selects expert models for implementation and summarizes the responses of intermediate planned tasks. Other LLMs serve as task executors, completing intermediate tasks in their areas of expertise.

Sentiment Analysis through LLM Negotiations: Related Work

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Xiaofei Sun, Zhejiang University & xiaofei_sun@zju.edu.cn;
(2) Xiaoya Li, Shannon.AI, Bytedance & xiaoya_li@shannonai.com;
(3) Shengyu Zhang, Zhejiang University & sy_zhang@zju.edu.cn;
(4) Shuhe Wang, Peking University & wangshuhe@stu.pku.edu.cn;
(5) Fei Wu, Zhejiang University & wufei@zju.edu.cn;
(6) Jiwei Li, Zhejiang University &  jiwei_li@zju.edu.cn;
(7) Tianwei Zhang, Nanyang Technological University & tianwei.zhang@ntu.edu.sg;
(8) Guoyin Wang, Bytedance & guoyin.wang@bytedance.com. Table of Links Abstract and Introduction
Related Work
LLM Negotiation for Sentiment Analysis
Experiments
Ablation Studies
Conclusion and References 4 Experiments To evaluate the effectiveness of the proposed method, we use GPT-3.5, GPT-4 (OpenAI, 2023) and InstructGPT3.5 (Ouyang et al., 2022) [1] as backbones for the multi-model negotiation method. In this process, we use the fine-tuned RoBERTa-Large (Liu et al., 2019) as the similarity function for retrieving k nearest neighbors as demonstrations. In the empirical study, we investigate the following three distinct ICL approaches, offering insights of integrating such methods for sentiment analysis. • Vanilla ICL: the sentiment analysis task is finished by asking a LLM with a prompt to generate sentiment-intensive text without gradient updates. In practice, we conduct two sets of experiments under this setting with GPT3.5 and GPT-4, respectively. • Self-Negotiation: the task is finished by using one LLM to discriminate and correct the answer generated by itself. We conduct two experiments with GPT3.5 and GPT-4 and get two results. • Negotiation with two LLMs: the task is completed by employing two different LLMs to take turns performing as the answer generator and discriminator. Specifically, we conduct one set of experiment with GPT3.5 and GPT-4. 4.1 Datasets We conduct experiments on six sentiment analysis datasets, including SST-2 (Socher et al., 2013), Movie Review (Zhang et al., 2015), Twitter (Rosenthal et al., 2019), Yelp-Binary (Zhang et al., 2015), AmazonBinary (Zhang et al., 2015), and IMDB (Maas et al., 2011b). More details of the datasets are shown as follows: • SST-2 (Socher et al., 2013): SST-2 is a binary (i.e., positive, negative) sentiment classification dataset and contains movie review snippets from the Rotton Tomato. We follow Socher et al. (2013) and use the train, valid, test splits with the number of examples of 67,349, 872, 1,821, respectively. • Movie Review (MR) (Zhang et al., 2015): Movie Reviews is a dataset for use in sentiment-analysis experiments. Available are collections of movie-review documents labeled with respect to their overall sentiment polarity (i.e., positive or negative). • Twitter (Rosenthal et al., 2019): Twitter is a three-class (i.e., positive, negative, neutral) sentiment analysis dataset, aiming to detecting whether a piece of text expresses a sentiment polarity in respect to a specific topic, such as a person, a product, or an event. The dataset is origin a shared task at SemEval 2017, containing 50,333 examples in the train set and 12,284 examples in the test set. • Yelp-Binary (Zhang et al., 2015): Yelp is a binary (i.e., positive, negative) sentiment analysis dataset, containing product reviews from Yelp. The dataset has 560,000 trainig samples and 38,000 testing samples. • Amazon-Binary (Zhang et al., 2015): Amazon is a binary sentiment classification task, containing product reviews from Amazon with 3,600,000 examples in the train set and 400,000 examples in the test set. • IMDB (Maas et al., 2011b): The IMDB dataset contains movie reviews along with their associated binary sentiment polarity labels. The dataset contains 50,000 reviews split evenly into 25k train and 25k test sets. The overall distribution of labels is balanced (25k positive and 25k negative). We use accuracy as the evaluation metric. 4.2 Baselines We use supervised neural network models and ICL approaches with LLMs as baselines for comparisons. For supervised methods, we choose the following four models: • DRNN (Wang, 2018): incorporates positioninvariance into RNN and CNN models by limiting the distance of information flow in neural networks. • RoBERTa (Liu et al., 2019): is a reimplementation of BERT (Devlin et al., 2018) aiming to improve performances on NLP downstream tasks. In this paper, we report results achieved by fine-tuned RoBERTa-Large. • XLNet (Yang et al., 2019): is a pretrained autoregressive LM that integrates Transformer-XL (Dai et al., 2019) and enables to learn bidirectional contexts by maximizing the expected likelihood over all permutations of the factorization order. • UDA (Xie et al., 2020): is short for Unsupervised Data Augmentation, which is a data augmentation strategy that employs a consistency loss function for unsupervised and supervised training stages. Performances in Table 1 are obtained by BERT-Large with UDA. • BERTweet (Nguyen et al., 2020): is a pretrained language model for English Tweets. The BERTweet has the same number of parameters as RoBERTa-Base. • EFL (Wang et al., 2021): is backboned by RoBERTa-Large and fine-tuned on natural language entailment examples. For ICL approaches, we report experimental results with LLMs from the following studies: • Zhang et al. (2023d): presents a comprehensive study for applying LLMs (i.e., FLan-UL2, T5 and ChatGPT) on sentiment analysis tasks. Experimental results in the Table 1 are obtained in few-shot(k = 5) settings. • InstructGPT-3.5 (Ouyang et al., 2022): is a large language model trained to follow human instructions. Experimental results in the Table 1 are achieved by the text-davinci-003 model. • IDS (Qin et al., 2023a): propose an Iterative Demonstration Selection (IDS) strategy to select demonstrations from diversity, similarity, and task-specific perspectives. Results shown in Table 1 are obtained by using GPT-3.5 (gpt-3.5-turbo). • GPT-4 (OpenAI, 2023): is a large multimodal model, achieving human-level performance on various NLP benchmarks. • Self-negotiation: The same LLM acts as both the roles of the generator and the discriminator. 4.3 Results and analysis Experiment results are shown in Table 1. As can be seen in the table, compared to vanilla ICL, following the generate-discriminate paradigm with one LLM (self-negotiation) receives performance gains on six sentiment analysis datasets: GPT-3.5 gains +0.9 on average; GPT-4 receives +1.0 acc on average. This phenomenon illustrates that the LLM, performing as the answer discriminator, can correct a portion of errors caused by the task generator. We also observe that using two different LLMs as the task generator and task discriminator in turn introduces significant performance improvements compared to merely using one model. Negotiations with two LLMs outperform the self-negotiation method by +1.7, +2.1, and +2.3 in terms of accuracy on MR, Twitter, IMDB datasets, respectively. The reason for this phenomenon is that using two different LLMs finish the sentiment analysis task through negotiations can take the advantage of different understandings of the given input and unleash the power of two LLMs, leading to more accurate decisions. We also find that when introduce a third LLM to resolve the disagreement between the flippled-roled negotiations, additional performance boost can be obtained. This demonstrates that the third LLM can resolve conflicts between two LLMs through multiple negotiations and improve performances on the sentiment analysis task. It is noteworthy that the multi-model negotiation method outperforms the supervised method RoBERTa-Large by +0.9 on the MR dataset, and bridges the gap between vanilla ICL and the supervised method: achieving 94.1 (+1.4) accuracy on SST-2; 92.1 (+2.7) on Twitter; 96.3 (+2.5) on Yelp-2; 87.2 (+3.7) on Amazon-2; and 94.5 (+6.0) on IMDB dataset. [1] text-davinci-003 This paper is available on arxiv under CC 4.0 license. Authors: (1) Xiaofei Sun, Zhejiang University & xiaofei_sun@zju.edu.cn; (2) Xiaoya Li, Shannon.AI, Bytedance & xiaoya_li@shannonai.com; (3) Shengyu Zhang, Zhejiang University & sy_zhang@zju.edu.cn; (4) Shuhe Wang, Peking University & wangshuhe@stu.pku.edu.cn; (5) Fei Wu, Zhejiang University & wufei@zju.edu.cn; (6) Jiwei Li, Zhejiang University &  jiwei_li@zju.edu.cn; (7) Tianwei Zhang, Nanyang Technological University & tianwei.zhang@ntu.edu.sg; (8) Guoyin Wang, Bytedance & guoyin.wang@bytedance.com. This paper is available on arxiv under CC 4.0 license. Authors: (1) Xiaofei Sun, Zhejiang University & xiaofei_sun@zju.edu.cn; (2) Xiaoya Li, Shannon.AI, Bytedance & xiaoya_li@shannonai.com; (3) Shengyu Zhang, Zhejiang University & sy_zhang@zju.edu.cn; (4) Shuhe Wang, Peking University & wangshuhe@stu.pku.edu.cn; (5) Fei Wu, Zhejiang University & wufei@zju.edu.cn; (6) Jiwei Li, Zhejiang University &  jiwei_li@zju.edu.cn; (7) Tianwei Zhang, Nanyang Technological University & tianwei.zhang@ntu.edu.sg; (8) Guoyin Wang, Bytedance & guoyin.wang@bytedance.com. Table of Links Abstract and Introduction Related Work LLM Negotiation for Sentiment Analysis Experiments Ablation Studies Conclusion and References Abstract and Introduction Abstract and Introduction Related Work Related Work LLM Negotiation for Sentiment Analysis LLM Negotiation for Sentiment Analysis Experiments Experiments Ablation Studies Ablation Studies Conclusion and References Conclusion and References 4 Experiments To evaluate the effectiveness of the proposed method, we use GPT-3.5, GPT-4 (OpenAI, 2023) and InstructGPT3.5 (Ouyang et al., 2022) [1] as backbones for the multi-model negotiation method. In this process, we use the fine-tuned RoBERTa-Large (Liu et al., 2019) as the similarity function for retrieving k nearest neighbors as demonstrations. In the empirical study, we investigate the following three distinct ICL approaches, offering insights of integrating such methods for sentiment analysis. • Vanilla ICL: the sentiment analysis task is finished by asking a LLM with a prompt • Vanilla ICL: to generate sentiment-intensive text without gradient updates. In practice, we conduct two sets of experiments under this setting with GPT3.5 and GPT-4, respectively. • Self-Negotiation: the task is finished by using one LLM to discriminate and correct the • Self-Negotiation: answer generated by itself. We conduct two experiments with GPT3.5 and GPT-4 and get two results. • Negotiation with two LLMs: the task is completed by employing two different • Negotiation with two LLMs: LLMs to take turns performing as the answer generator and discriminator. Specifically, we conduct one set of experiment with GPT3.5 and GPT-4. 4.1 Datasets We conduct experiments on six sentiment analysis datasets, including SST-2 (Socher et al., 2013), Movie Review (Zhang et al., 2015), Twitter (Rosenthal et al., 2019), Yelp-Binary (Zhang et al., 2015), AmazonBinary (Zhang et al., 2015), and IMDB (Maas et al., 2011b). More details of the datasets are shown as follows: • SST-2 (Socher et al., 2013): SST-2 is a binary (i.e., positive, negative) sentiment • SST-2 classification dataset and contains movie review snippets from the Rotton Tomato. We follow Socher et al. (2013) and use the train, valid, test splits with the number of examples of 67,349, 872, 1,821, respectively. • Movie Review (MR) (Zhang et al., 2015): Movie Reviews is a dataset for use in sentiment-analysis experiments. Available are collections of movie-review documents labeled with respect to their overall sentiment polarity (i.e., positive or negative). • Movie Review (MR) • Twitter (Rosenthal et al., 2019): Twitter is a three-class (i.e., positive, negative, neutral) sentiment analysis dataset, aiming to detecting whether a piece of text expresses a sentiment polarity in respect to a specific topic, such as a person, a product, or an event. The dataset is origin a shared task at SemEval 2017, containing 50,333 examples in the train set and 12,284 examples in the test set. • Twitter • Yelp-Binary (Zhang et al., 2015): Yelp is a binary (i.e., positive, negative) sentiment analysis dataset, containing product reviews from Yelp. The dataset has 560,000 trainig samples and 38,000 testing samples. • Yelp-Binary • Amazon-Binary (Zhang et al., 2015): Amazon is a binary sentiment classification task, containing product reviews from Amazon with 3,600,000 examples in the train set and 400,000 examples in the test set. • Amazon-Binary • IMDB (Maas et al., 2011b): The IMDB dataset contains movie reviews along with their associated binary sentiment polarity labels. The dataset contains 50,000 reviews split evenly into 25k train and 25k test sets. The overall distribution of labels is balanced (25k positive and 25k negative). • IMDB We use accuracy as the evaluation metric. 4.2 Baselines We use supervised neural network models and ICL approaches with LLMs as baselines for comparisons. For supervised methods, we choose the following four models: • DRNN (Wang, 2018): incorporates positioninvariance into RNN and CNN models by limiting the distance of information flow in neural networks. • DRNN • RoBERTa (Liu et al., 2019): is a reimplementation of BERT (Devlin et al., 2018) aiming to improve performances on NLP downstream tasks. In this paper, we report results achieved by fine-tuned RoBERTa-Large. RoBERTa • XLNet (Yang et al., 2019): is a pretrained autoregressive LM that integrates Transformer-XL (Dai et al., 2019) and enables to learn bidirectional contexts by maximizing the expected likelihood over all permutations of the factorization order. XLNet • UDA (Xie et al., 2020): is short for Unsupervised Data Augmentation, which is a data augmentation strategy that employs a consistency loss function for unsupervised and supervised training stages. Performances in Table 1 are obtained by BERT-Large with UDA. • UDA • BERTweet (Nguyen et al., 2020): is a pretrained language model for English Tweets. The BERTweet has the same number of parameters as RoBERTa-Base. • BERTweet • EFL (Wang et al., 2021): is backboned by RoBERTa-Large and fine-tuned on natural language entailment examples. EFL For ICL approaches, we report experimental results with LLMs from the following studies: • Zhang et al. (2023d): presents a comprehensive study for applying LLMs (i.e., FLan-UL2, T5 and ChatGPT) on sentiment analysis tasks. Experimental results in the Table 1 are obtained in few-shot(k = 5) settings. • InstructGPT-3.5 (Ouyang et al., 2022): is a large language model trained to follow human instructions. Experimental results in the Table 1 are achieved by the text-davinci-003 model. InstructGPT-3.5 • IDS (Qin et al., 2023a): propose an Iterative Demonstration Selection (IDS) strategy to select demonstrations from diversity, similarity, and task-specific perspectives. Results shown in Table 1 are obtained by using GPT-3.5 (gpt-3.5-turbo). • IDS • GPT-4 (OpenAI, 2023): is a large multimodal model, achieving human-level performance on various NLP benchmarks. • GPT-4 • Self-negotiation: The same LLM acts as both the roles of the generator and the discriminator. • Self-negotiation: 4.3 Results and analysis Experiment results are shown in Table 1. As can be seen in the table, compared to vanilla ICL, following the generate-discriminate paradigm with one LLM (self-negotiation) receives performance gains on six sentiment analysis datasets: GPT-3.5 gains +0.9 on average; GPT-4 receives +1.0 acc on average. This phenomenon illustrates that the LLM, performing as the answer discriminator, can correct a portion of errors caused by the task generator. We also observe that using two different LLMs as the task generator and task discriminator in turn introduces significant performance improvements compared to merely using one model. Negotiations with two LLMs outperform the self-negotiation method by +1.7, +2.1, and +2.3 in terms of accuracy on MR, Twitter, IMDB datasets, respectively. The reason for this phenomenon is that using two different LLMs finish the sentiment analysis task through negotiations can take the advantage of different understandings of the given input and unleash the power of two LLMs, leading to more accurate decisions. We also find that when introduce a third LLM to resolve the disagreement between the flippled-roled negotiations, additional performance boost can be obtained. This demonstrates that the third LLM can resolve conflicts between two LLMs through multiple negotiations and improve performances on the sentiment analysis task. It is noteworthy that the multi-model negotiation method outperforms the supervised method RoBERTa-Large by +0.9 on the MR dataset, and bridges the gap between vanilla ICL and the supervised method: achieving 94.1 (+1.4) accuracy on SST-2; 92.1 (+2.7) on Twitter; 96.3 (+2.5) on Yelp-2; 87.2 (+3.7) on Amazon-2; and 94.5 (+6.0) on IMDB dataset. [1] text-davinci-003

Sentiment Analysis through LLM Negotiations: Experiments

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Xiaofei Sun, Zhejiang University & xiaofei_sun@zju.edu.cn;
(2) Xiaoya Li, Shannon.AI, Bytedance & xiaoya_li@shannonai.com;
(3) Shengyu Zhang, Zhejiang University & sy_zhang@zju.edu.cn;
(4) Shuhe Wang, Peking University & wangshuhe@stu.pku.edu.cn;
(5) Fei Wu, Zhejiang University & wufei@zju.edu.cn;
(6) Jiwei Li, Zhejiang University &  jiwei_li@zju.edu.cn;
(7) Tianwei Zhang, Nanyang Technological University & tianwei.zhang@ntu.edu.sg;
(8) Guoyin Wang, Bytedance & guoyin.wang@bytedance.com. Table of Links Abstract and Introduction
Related Work
LLM Negotiation for Sentiment Analysis
Experiments
Ablation Studies
Conclusion and References Abstract A standard paradigm for sentiment analysis is to rely on a singular LLM that makes the decision in a single round under the framework of in-context learning. This framework suffers the key disadvantage that the single-turn output generated by a single LLM might not deliver the perfect decision, just as humans sometimes need multiple attempts to get things right. This is especially true for the task of sentiment analysis where deep reasoning is required to address the complex linguistic phenomenon (e.g., clause composition, irony, etc) in the input. To address this issue, this paper introduces a multi-LLM negotiation framework for sentiment analysis. The framework consists of a reasoning-infused generator to provide decision along with rationale, a explanationderiving discriminator to evaluate the credibility of the generator. The generator and the discriminator iterate until a consensus is reached. The proposed framework naturally addressed the aforementioned challenge, as we are able to take the complementary abilities of two LLMs, have them use rationale to persuade each other for correction. Experiments on a wide range of sentiment analysis benchmarks (SST-2, Movie Review, Twitter, yelp, amazon, IMDB) demonstrate the effectiveness of proposed approach: it consistently yields better performances than the ICL baseline across all benchmarks, and even superior performances to supervised baselines on the Twitter and movie review datasets. 1 Introduction Sentiment analysis (Pang and Lee, 2008; Go et al., 2009; Maas et al., 2011a; Zhang and Liu, 2012; Baccianella et al., 2010; Medhat et al., 2014; Bakshi et al., 2016; Zhang et al., 2018) aims to extract opinion polarity expressed by a chunk of text. Recent advances in large language models (LLMs) (Brown et al., 2020; Ouyang et al., 2022; Touvron et al., 2023a,b; Anil et al., 2023; Zeng et al., 2022b; OpenAI, 2023; Bai et al., 2023) open a new door for the resolving the task (Lu et al., 2021; Kojima et al., 2022; Wang et al., 2022b; Wei et al., 2022b; Wan et al., 2023; Wang et al., 2023; Sun et al., 2023b,a; Lightman et al., 2023; Li et al., 2023; Schick et al., 2023): under the paradigm of in-context learning (ICL), LLMs are able to achieve performances comparable to supervised learning strategies (Lin et al., 2021; Sun et al., 2021; Phan and Ogunbona, 2020; Dai et al., 2021) with only a small number of training examples. Existing approaches that harness LLMs for sentiment analysis usually rely on a singular LLM, and make a decision in a single round under ICL. This strategy suffers from the following disadvantage: the single-turn output generated by a single LLM might not deliver the perfect response: Just as humans sometimes need multiple attempts to get things right, it might take multiple rounds before an LLM makes the right decision. This is especially true for the task of sentiment analysis, where LLMs usually need to articulate the reasoning process to address the complex linguistic phenomenon (e.g., clause composition, irony, etc) in the input sentence. To address the this issue, in this paper, we propose a multi-LLM negotiation strategy for sentiment analysis. The core of the proposed strategy is a generator-discriminator framework, where one LLM acts as the generator (G) to produce sentiment decisions, while the other acts as a discriminator (D), tasked with evaluating the credibility of the generated output from the first LLM. The proposed method innovates on three aspects: (1) Reasoning-infused generator (G): an LLM that adheres to a structured reasoning chain, enhancing the ICL of the generator while offering the discriminator the evidence and insights to evaluate its validity; (2) Explanation deriving discriminator (D); other LLM designed to offer post-evaluation rationales for its judgments; (3) Negotiation: two LLMs act as the roles of the generator and the discriminator, and perform the negotiation until a consensus is reached. This strategy harnesses the collective abilities of the two LLMs and provide with the channel for the model to correct imperfect responses, and thus naturally resolves the issue that a single LLM cannot yield the correct decision on its first try. The contributions of this work can be summarized as follows: 1) we provide a novel perspective on how sentiment analysis can benefit from multi-LLM negotiation. 2) we introduce a Generator Discriminator Role-switching DecisionMaking framework that enables multi-LLM collaboration through iteratively generating and validating sentiment categorizations. 3) our empirical findings offer evidence for the efficacy of the proposed approach: experiments on a wide range of sentiment analysis benchmarks (SST-2, Movie Review, Twitter, yelp, amazon, IMDB) demonstrate that the proposed method consistently yields better performances than the ICL baseline across all benchmarks, and even superior performances to supervised baselines on the Twitter and movie review datasets. This paper is available on arxiv under CC 4.0 license. Authors: (1) Xiaofei Sun, Zhejiang University & xiaofei_sun@zju.edu.cn; (2) Xiaoya Li, Shannon.AI, Bytedance & xiaoya_li@shannonai.com; (3) Shengyu Zhang, Zhejiang University & sy_zhang@zju.edu.cn; (4) Shuhe Wang, Peking University & wangshuhe@stu.pku.edu.cn; (5) Fei Wu, Zhejiang University & wufei@zju.edu.cn; (6) Jiwei Li, Zhejiang University &  jiwei_li@zju.edu.cn; (7) Tianwei Zhang, Nanyang Technological University & tianwei.zhang@ntu.edu.sg; (8) Guoyin Wang, Bytedance & guoyin.wang@bytedance.com. This paper is available on arxiv under CC 4.0 license. Authors: (1) Xiaofei Sun, Zhejiang University & xiaofei_sun@zju.edu.cn; (2) Xiaoya Li, Shannon.AI, Bytedance & xiaoya_li@shannonai.com; (3) Shengyu Zhang, Zhejiang University & sy_zhang@zju.edu.cn; (4) Shuhe Wang, Peking University & wangshuhe@stu.pku.edu.cn; (5) Fei Wu, Zhejiang University & wufei@zju.edu.cn; (6) Jiwei Li, Zhejiang University &  jiwei_li@zju.edu.cn; (7) Tianwei Zhang, Nanyang Technological University & tianwei.zhang@ntu.edu.sg; (8) Guoyin Wang, Bytedance & guoyin.wang@bytedance.com. Table of Links Abstract and Introduction Related Work LLM Negotiation for Sentiment Analysis Experiments Ablation Studies Conclusion and References Abstract and Introduction Abstract and Introduction Related Work Related Work LLM Negotiation for Sentiment Analysis LLM Negotiation for Sentiment Analysis Experiments Experiments Ablation Studies Ablation Studies Conclusion and References Conclusion and References Abstract A standard paradigm for sentiment analysis is to rely on a singular LLM that makes the decision in a single round under the framework of in-context learning. This framework suffers the key disadvantage that the single-turn output generated by a single LLM might not deliver the perfect decision, just as humans sometimes need multiple attempts to get things right. This is especially true for the task of sentiment analysis where deep reasoning is required to address the complex linguistic phenomenon (e.g., clause composition, irony, etc) in the input. To address this issue, this paper introduces a multi-LLM negotiation framework for sentiment analysis. The framework consists of a reasoning-infused generator to provide decision along with rationale, a explanationderiving discriminator to evaluate the credibility of the generator. The generator and the discriminator iterate until a consensus is reached. The proposed framework naturally addressed the aforementioned challenge, as we are able to take the complementary abilities of two LLMs, have them use rationale to persuade each other for correction. Experiments on a wide range of sentiment analysis benchmarks (SST-2, Movie Review, Twitter, yelp, amazon, IMDB) demonstrate the effectiveness of proposed approach: it consistently yields better performances than the ICL baseline across all benchmarks, and even superior performances to supervised baselines on the Twitter and movie review datasets. 1 Introduction Sentiment analysis (Pang and Lee, 2008; Go et al., 2009; Maas et al., 2011a; Zhang and Liu, 2012; Baccianella et al., 2010; Medhat et al., 2014; Bakshi et al., 2016; Zhang et al., 2018) aims to extract opinion polarity expressed by a chunk of text. Recent advances in large language models (LLMs) (Brown et al., 2020; Ouyang et al., 2022; Touvron et al., 2023a,b; Anil et al., 2023; Zeng et al., 2022b; OpenAI, 2023; Bai et al., 2023) open a new door for the resolving the task (Lu et al., 2021; Kojima et al., 2022; Wang et al., 2022b; Wei et al., 2022b; Wan et al., 2023; Wang et al., 2023; Sun et al., 2023b,a; Lightman et al., 2023; Li et al., 2023; Schick et al., 2023): under the paradigm of in-context learning (ICL), LLMs are able to achieve performances comparable to supervised learning strategies (Lin et al., 2021; Sun et al., 2021; Phan and Ogunbona, 2020; Dai et al., 2021) with only a small number of training examples. Existing approaches that harness LLMs for sentiment analysis usually rely on a singular LLM, and make a decision in a single round under ICL. This strategy suffers from the following disadvantage: the single-turn output generated by a single LLM might not deliver the perfect response: Just as humans sometimes need multiple attempts to get things right, it might take multiple rounds before an LLM makes the right decision. This is especially true for the task of sentiment analysis, where LLMs usually need to articulate the reasoning process to address the complex linguistic phenomenon (e.g., clause composition, irony, etc) in the input sentence. To address the this issue, in this paper, we propose a multi-LLM negotiation strategy for sentiment analysis. The core of the proposed strategy is a generator-discriminator framework, where one LLM acts as the generator (G) to produce sentiment decisions, while the other acts as a discriminator (D), tasked with evaluating the credibility of the generated output from the first LLM. The proposed method innovates on three aspects: (1) Reasoning-infused generator (G): an LLM that adheres to a structured reasoning chain, enhancing the ICL of the generator while offering the discriminator the evidence and insights to evaluate its validity; (2) Explanation deriving discriminator (D); other LLM designed to offer post-evaluation rationales for its judgments; (3) Negotiation: two LLMs act as the roles of the generator and the discriminator, and perform the negotiation until a consensus is reached. This strategy harnesses the collective abilities of the two LLMs and provide with the channel for the model to correct imperfect responses, and thus naturally resolves the issue that a single LLM cannot yield the correct decision on its first try. The contributions of this work can be summarized as follows: 1) we provide a novel perspective on how sentiment analysis can benefit from multi-LLM negotiation. 2) we introduce a Generator Discriminator Role-switching DecisionMaking framework that enables multi-LLM collaboration through iteratively generating and validating sentiment categorizations. 3) our empirical findings offer evidence for the efficacy of the proposed approach: experiments on a wide range of sentiment analysis benchmarks (SST-2, Movie Review, Twitter, yelp, amazon, IMDB) demonstrate that the proposed method consistently yields better performances than the ICL baseline across all benchmarks, and even superior performances to supervised baselines on the Twitter and movie review datasets.

Sentiment Analysis through LLM Negotiations: Abstract and Introduction 

Sentiment Analysis through LLM Negotiations: Conclusion and References

PIECHAIN Demo: Exploring a Practical Blockchain Interoperability Framework

পাইচেন ডেমো: একটি ব্যবহারিক ব্লকচেইন ইন্টারঅপারেবিলিটি ফ্রেমওয়ার্ক অন্বেষণ করা

PIECHAIN-Demo: Erkundung eines praktischen Blockchain-Interoperabilitätsrahmens

Demostración de PIECHAIN: Explorando un marco práctico de interoperabilidad de Blockchain

Démo PIECHAIN : Explorer un cadre pratique d'interopérabilité de la blockchain

PIECHAIN डेमो: एक व्यावहारिक ब्लॉकचेन इंटरऑपरेबिलिटी फ्रेमवर्क की खोज

PIECHAIN デモ: 実用的なブロックチェーン相互運用性フレームワークの探究

PIECHAIN 데모: 실용적인 블록체인 상호 운용성 프레임워크 탐색

Demonstração PIECHAIN: Explorando uma estrutura prática de interoperabilidade Blockchain

Демонстрация PIECHAIN: изучение практической структуры взаимодействия блокчейнов

PIECHAIN Demosu: Pratik Bir Blockchain Birlikte Çalışabilirlik Çerçevesini Keşfetmek

Bản trình diễn PIECHAIN: Khám phá Khung tương tác Blockchain thực tế

PIECHAIN 演示：探索实用的区块链互操作性框架

At some point, too many people will have lost too much Bitcoin that they will meet to talk about it. Later, they will opt to do something about it. There can only be a (decreasing number) of bitcoins Lost cryptocurrency is a unique beast, quite different from lost information for 2 reasons: 1. We can continue maintaining its value. Right? Is it really still valuable? 2. Other people know it is lost. They simply check the blockchain. Whereas with lost information, nobody else can tell except those who have lost that intel. Take Bitcoin as an example. We still say 'There can only be 21 million'. But if this includes even lost bitcoins, then we are counting our losses as assets! That is very strange. Imagine if you were an accountant for a major company. The company deals in all sorts of assets, but sometimes writes some physical assets off as lost either due to theft, fire outbreak, or irreparable damage. But to your shock, the manager insists that not only do you keep counting those assets, but also, count them as fully functional assets whose value is going up every year. "But they are damaged", you might say. "Yeah, but they are still our assets" "What, how?" "There is hope we can recover them exactly as they were before they were lost. And then some". It’s hard to fathom. It indeed feels like Alice in Wonderland, where cards talk, a piece of cake can make one bigger, or smaller, and a cat can disappear leaving only its grin behind. Bitcoin and most crypto are the same. The question is thus; Is real value riding on all coins? Even when some are lost? Certainly, supply and demand economics might make all the coins feel equally valuable hence we would say that if Bitcoin is at $70,000 then the market cap is $1.47 trillion. But taking the figures as per this reddit post on lost bitcoins, if 6 million are lost then only 15 million coins are existing which are backed by a market cap of $1.05 trillion. Less by $420 billion. This does deflate our dreams and begs the question --> are we kidding ourselves? The road to Zero bitcoins By some estimates, 4% of 21,000,000 bitcoins continue to be lost every year. How many shall be lost, going forward? Let's assume this 4% holds true. 4% × 21,000,000 = 840,000 bitcoins. This is very steep. Well then, in 15 years, we shall lose 840,000 * 15 = 12,600,000 Add 6 million to this batch and circa 2039, 'There can only be 2,400,000 bitcoins' When will they be finished? Now, a little hope is in order. The 4% cannot hold steady forever, so it would be wise to say it too will be a declining figure as we progress. Because as Bitcoins get more valuable, people will be more careful with their keys. It is inevitable. Taking it at face value though, we shall run out of bitcoins to trade within the next 18 years. So Circa 2042. I hope the naysayers will be back to tell us they told us so, or to plead guilty of doomism and explain why there are still many millions of Bitcoins being traded daily. However, it certainly looks like way before the year 2137 when the last satoshi will be mined, we shall hit a big wall as per the coins lost vs the coins in the available supply. When enough is enough, for lost Bitcoins Assume at the time this shocking reality hits the Bitcoin community, we have only 4 million coins tradable around the world. Assume even Michael Saylor shall have lost some of his keys/coins. What then? Well, the price of a single coin, feeling so much demand, will spike to about $10 million, and then it will dawn on everybody. Bitcoin has a $40 trillion market capitalization and not a $210 trillion market capitalization. Right now, this is an elephant 🐘 in the Bitcoin room, but it is still a baby and we are all happy to pet it and feed it with careless abandon. Soon, however, it will become a giant. A big fat frustration. At $10 trillion per coin, the fees to move even a few sats will likely be thousands of dollars because; a) the Bitcoin reward is smaller. b) miners have also lost their coins. c) losing coins to hackers will be most likely (hackers will be sniffing all over every wallet, waiting for the SSL to get some slight holes) Everybody will be losing coins. It will be wild. But before I proceed? Why do people lose keys hence coins? Well, if you are using the key every time, sometimes changing it this way and that way to maintain your security (because AI powered cameras may be watching), it so happens that you are bound to make a mistake and lose the key. Or else, be hacked (since you cannot fathom changing the key all the time). Like smart people must have said, meat brains are not good at holding random numbers or random sequences of words. Luke Dash Jnr, a seasoned cypherpunk, was hacked last year. He lost 200 bitcoins. Elon Musk may have lost his Bitcon keys back in '20. So, shit happens. To hard fork those lost coins back, or not. That is the question So here's the thing. We wake up and Bitcoin is seizing up. Crashing into its mass and threatening to take our financial dreams with it when it turns into a black hole of lost keys / burned coins. We also wake up and realize that the debt spiral is still sucking us down with it, even as we hodl Bitcoin. Climate is now a real issue and oh, AI is giving us headaches. Too many addictive cat videos. Too many coins are lost, the blocks are always full so confirmations take decades, the core software is too large, the fees are too high. So we sit down, like AA group members, and decide that continuing to preach financial freedom yet the currency is fast tending towards technological obsolescence, is like being high on alcohol and thinking that one is blissful for other reasons. We need to quit the 'lost coins are good for all' alcohol. In short, it will be time for a hard fork. The Hard Fork --> Bitcoin ver. 2.0 Innovation comes full circle. After factoring in the reality of available supply and not merely supply, we could let Satoshi Nakamoto's 2 million or so coins be our target practice and our saving grace. One shot and bull’s eye. Trillions of dollars pour down from the Bitcoin piñata. Like manna from the heavens. Right? Alas, There shall only be 4 million bitcoins and the value of lost coins, if "re-supplied" to the blockchain, will quickly deflate the value of the 4 million coins existing. Overall, lost coins would have helped the remaining coins get valuable to that point. Say $10 million per BTC. If you un-lose them by the most brute force of them all -- a hard fork -- you shock the demand economics and viola, have worth-less bitcoins than you started with. Now whoever is holding their previously un-lost bitcoins cannot be happy about that. It begs the question, what would they do? Refuse the hard fork outright. Obviously. Indeed, even if the value of the bitcoins would overall increase the market cap of the available supply, we can be damn sure it would reduce the value of each individual coin. Supply and Demand. Economics 101. The Big Question: Is this a financial revolution for the better, or for the worse? For example, let's say we had 4 million coins left. We then redeem the coins in the wallets of those proven deceased without any heir. Say Satoshi Finney is that first choice. At $10 million per coin, 4 million coins give up a market cap of 40 trillion USD. Add 2 million coins to the available supply but have the price shocked from 10 million to only 7 million. Total availability supply = 6 million. 6 million x 7 million USD = 42 trillion dollars. It is a good financial explosion. But to whom? Who gets the money?? Who makes the ultimate sacrifice of accepting to end up with less money than before? If rational and educated human beings cannot agree on simple (obvious) things like "Are fossil fuels necessary for economic progress or not?", how can they agree on how to share this pie? It is a financial explosion, except the majority will not want it. Satoshi may have solved the Byzantine General's problem. Somebody needs to solve the "Goodness of the community over the Goodness of the individual" problem. Of course, with my limited brains, I know most people are wary of a Marxist dystopia sliding in during this very crucial process. E.g. The coins could instead be coded to go to a handful of powerful individuals, whereas before it seemed like they would go to people who deserved a financial turnaround. Especially in the wake of what we see today with government debt ballooning, government operatives hoping to snatch some of this reclaimed BTC so as to help the government pay its gigantic debt is not an impossibility. Talk about being stuck between a rock and a hard place. Not the best kind of sandwich. At some point, too many people will have lost too much Bitcoin that they will meet to talk about it. Bitcoin Later, they will opt to do something about it. There can only be a (decreasing number) of bitcoins L ost cryptocurrency is a unique beast, quite different from lost information for 2 reasons: ost cryptocurrency is a unique beast, quite different from lost information for 2 reasons: 1. We can continue maintaining its value. Right? Is it really still valuable? Is it really still valuable? really 2. Other people know it is lost. They simply check the blockchain. Whereas with lost information, nobody else can tell except those who have lost that intel. Take Bitcoin as an example. We still say 'There can only be 21 million'. But if this includes even lost bitcoins, then we are counting our losses as assets! That is very strange. Imagine if you were an accountant for a major company. The company deals in all sorts of assets, but sometimes writes some physical assets off as lost either due to theft, fire outbreak, or irreparable damage. But to your shock, the manager insists that not only do you keep counting those assets, but also, count them as fully functional assets whose value is going up every year. " But they are damaged ", you might say. But they are damaged " Yeah, but they are still our assets " Yeah, but they are still our assets " What, how? " What, how? " There is hope we can recover them exactly as they were before they were lost. There is hope we can recover them exactly as they were before they were lost. And then some ". And then some It’s hard to fathom. It indeed feels like Alice in Wonderland, where cards talk, a piece of cake can make one bigger, or smaller, and a cat can disappear leaving only its grin behind. Bitcoin and most crypto are the same. The question is thus; Is real value riding on all coins? Even when some are lost? Certainly, supply and demand economics might make all the coins feel equally valuable hence we would say that if Bitcoin is at $70,000 then the market cap is $1.47 trillion. But taking the figures as per this reddit post on lost bitcoins , if 6 million are lost then only 15 million coins are existing which are backed by a market cap of $1.05 trillion. reddit post on lost bitcoins Less by $420 billion. This does deflate our dreams and begs the question --> are we kidding ourselves? The road to Zero bitcoins By some estimates , 4% of 21,000,000 bitcoins continue to be lost every year. some estimates How many shall be lost, going forward? Let's assume this 4% holds true. 4% × 21,000,000 = 840,000 bitcoins. This is very steep. Well then, in 15 years, we shall lose 840,000 * 15 = 12,600,000 Add 6 million to this batch and circa 2039, 'There can only be 2,400,000 bitcoins' When will they be finished? Now, a little hope is in order. The 4% cannot hold steady forever, so it would be wise to say it too will be a declining figure as we progress. Because as Bitcoins get more valuable, people will be more careful with their keys. It is inevitable. Taking it at face value though, we shall run out of bitcoins to trade within the next 18 years. So Circa 2042. I hope the naysayers will be back to tell us they told us so, or to plead guilty of doomism and explain why there are still many millions of Bitcoins being traded daily. However, it certainly looks like way before the year 2137 when the last satoshi will be mined, we shall hit a big wall as per the coins lost vs the coins in the available supply. When enough is enough, for lost Bitcoins Assume at the time this shocking reality hits the Bitcoin community, we have only 4 million coins tradable around the world. Assume even Michael Saylor shall have lost some of his keys/coins. What then? Well, the price of a single coin, feeling so much demand, will spike to about $10 million, and then it will dawn on everybody. Bitcoin has a $40 trillion market capitalization and not a $210 trillion market capitalization. Right now, this is an elephant 🐘 in the Bitcoin room, but it is still a baby and we are all happy to pet it and feed it with careless abandon. Soon, however, it will become a giant. A big fat frustration. At $10 trillion per coin, the fees to move even a few sats will likely be thousands of dollars because; a) the Bitcoin reward is smaller. b) miners have also lost their coins. c) losing coins to hackers will be most likely (hackers will be sniffing all over every wallet, waiting for the SSL to get some slight holes) Everybody will be losing coins. It will be wild. But before I proceed? Why do people lose keys hence coins? Well, if you are using the key every time, sometimes changing it this way and that way to maintain your security (because AI powered cameras may be watching), it so happens that you are bound to make a mistake and lose the key. Or else, be hacked (since you cannot fathom changing the key all the time). Like smart people must have said, meat brains are not good at holding random numbers or random sequences of words. Luke Dash Jnr, a seasoned cypherpunk, was hacked last year. He lost 200 bitcoins. Elon Musk may have lost his Bitcon keys back in '20. So, shit happens. To hard fork those lost coins back, or not. That is the question So here's the thing. We wake up and Bitcoin is seizing up. Crashing into its mass and threatening to take our financial dreams with it when it turns into a black hole of lost keys / burned coins. We also wake up and realize that the debt spiral is still sucking us down with it, even as we hodl Bitcoin. Climate is now a real issue and oh, AI is giving us headaches. Too many addictive cat videos. Too many coins are lost, the blocks are always full so confirmations take decades, the core software is too large, the fees are too high. So we sit down, like AA group members, and decide that continuing to preach financial freedom yet the currency is fast tending towards technological obsolescence, is like being high on alcohol and thinking that one is blissful for other reasons. We need to quit the 'lost coins are good for all' alcohol. In short, it will be time for a hard fork. The Hard Fork --> Bitcoin ver. 2.0 Innovation comes full circle. Innovation comes full circle. After factoring in the reality of available supply and not merely supply, we could let Satoshi Nakamoto's 2 million or so coins be our target practice and our saving grace. One shot and bull’s eye. Trillions of dollars pour down from the Bitcoin piñata. Like manna from the heavens. Right? Alas, There shall only be 4 million bitcoins and the value of lost coins, if "re-supplied" to the blockchain, will quickly deflate the value of the 4 million coins existing. Overall, lost coins would have helped the remaining coins get valuable to that point. Say $10 million per BTC. If you un-lose them by the most brute force of them all -- a hard fork -- you shock the demand economics and viola, have worth-less bitcoins than you started with. Now whoever is holding their previously un-lost bitcoins cannot be happy about that. It begs the question, what would they do? Refuse the hard fork outright. Obviously. Indeed, even if the value of the bitcoins would overall increase the market cap of the available supply, we can be damn sure it would reduce the value of each individual coin. Supply and Demand. Economics 101. The Big Question: Is this a financial revolution for the better, or for the worse? For example, let's say we had 4 million coins left. We then redeem the coins in the wallets of those proven deceased without any heir. Say Satoshi Finney is that first choice. At $10 million per coin, 4 million coins give up a market cap of 40 trillion USD. Add 2 million coins to the available supply but have the price shocked from 10 million to only 7 million. Total availability supply = 6 million. 6 million x 7 million USD = 42 trillion dollars. It is a good financial explosion. But to whom? Who gets the money?? Who makes the ultimate sacrifice of accepting to end up with less money than before? If rational and educated human beings cannot agree on simple (obvious) things like "Are fossil fuels necessary for economic progress or not?" , how can they agree on how to share this pie? "Are fossil fuels necessary for economic progress or not?" It is a financial explosion, except the majority will not want it. Satoshi may have solved the Byzantine General's problem. Somebody needs to solve the "Goodness of the community over the Goodness of the individual" problem. Of course, with my limited brains, I know most people are wary of a Marxist dystopia sliding in during this very crucial process. E.g. The coins could instead be coded to go to a handful of powerful individuals, whereas before it seemed like they would go to people who deserved a financial turnaround. Especially in the wake of what we see today with government debt ballooning, government operatives hoping to snatch some of this reclaimed BTC so as to help the government pay its gigantic debt is not an impossibility. Talk about being stuck between a rock and a hard place. Not the best kind of sandwich.

Is Lost Cryptocurrency Still Valuable, and Can We Reclaim It? 

Authors: (1) JunJie Wee, Department of Mathematics, Michigan State University; (2) Jiahui Chen, Department of Mathematical Sciences, University of Arkansas; (3) Kelin Xia, Division of Mathematical Sciences, School of Physical and Mathematical Sciences Nanyang Technological University & xiakelin@ntu.edu.sg; (4)Guo-Wei Wei, Department of Mathematics, Michigan State University, Department of Biochemistry and Molecular Biology, Michigan State University, Department of Electrical and Computer Engineering, Michigan State University & xiakelin@ntu.edu.sg. Table of Links Abstract & Introduction Results Discussion Conclusion Materials and Methods Software and resources, Code and Data Availability Supporting Information, Acknowledgments & References Supporting Information Supporting Information is available for supplementary tables, figures, and methods. Acknowledgments This work was supported in part by NIH grants R01GM126189, R01AI164266, and R01AI146210, NSF grants DMS-2052983, DMS-1761320, and IIS-1900473, NASA grant 80NSSC21M0023, MSU Foundation, Bristol-Myers Squibb 65109, and Pfizer. It was supported in part by Nanyang Technological University Startup Grant M4081842.110, Singapore Ministry of Education Academic Research fund Tier 1 RG109/19 and Tier 2 MOE-T2EP20120-0013, MOE-T2EP20220- 0010, and MOE-T2EP20221-0003. References [1] Y. Qiu and G.-W. Wei, “Persistent spectral theory-guided protein engineering,” Nature Computational Science, vol. 3, no. 2, pp. 149–163, 2023. [2] R. Guerois, J. E. Nielsen, and L. Serrano, “Predicting changes in the stability of proteins and protein complexes: a study of more than 1000 mutations,” Journal of molecular biology, vol. 320, no. 2, pp. 369–387, 2002. [3] P. Sormanni, F. A. Aprile, and M. Vendruscolo, “The CamSol method of rational design of protein mutants with enhanced solubility,” Journal of molecular biology, vol. 427, no. 2, pp. 478–490, 2015. [4] Y. Tian, C. Deutsch, and B. Krishnamoorthy, “Scoring function to predict solubility mutagenesis,” Algorithms for Molecular Biology, vol. 5, no. 1, pp. 1–11, 2010. [5] Y. Yang, A. Niroula, B. Shen, and M. Vihinen, “PON-Sol: Prediction of effects of amino acid substitutions on protein solubility,” Bioinformatics, vol. 32, no. 13, pp. 2032–2034, 2016. [6] L. Paladin, D. Piovesan, and S. C. Tosatto, “SODA: Prediction of protein solubility from disorder and aggregation propensity,” Nucleic acids research, vol. 45, no. W1, pp. W236– W240, 2017. [7] J. Van Durme, G. De Baets, R. Van Der Kant, M. Ramakers, A. Ganesan, H. Wilkinson, R. Gallardo, F. Rousseau, and J. Schymkowitz, “Solubis: a webserver to reduce protein aggregation through mutation,” Protein Engineering, Design and Selection, vol. 29, no. 8, pp. 285–289, 2016. [8] M. Vihinen, “Solubility of proteins,” ADMET and DMPK, vol. 8, no. 4, pp. 391–399, 2020. [9] A.-M. Fernandez-Escamilla, F. Rousseau, J. Schymkowitz, and L. Serrano, “Prediction of sequence-dependent and mutational effects on the aggregation of peptides and proteins,” Nature Biotechnology, vol. 22, no. 10, pp. 1302–1306, 2004. [10] H. Land and M. S. Humble, “YASARA: A tool to obtain structural guidance in biocatalytic investigations,” Protein engineering: methods and protocols, pp. 43–67, 2018. [11] Y. Yang, L. Zeng, and M. Vihinen, “PON-Sol2: Prediction of effects of variants on protein solubility,” International Journal of Molecular Sciences, vol. 22, no. 15, p. 8027, 2021. [12] H. Edelsbrunner and J. L. Harer, Computational Topology: An Introduction. American Mathematical Society, 2022. [13] A. Zomorodian and G. Carlsson, “Computing Persistent Homology,” in Proceedings of the twentieth annual symposium on Computational geometry, pp. 347–356, 2004. [14] K. Xia and G.-W. Wei, “Persistent homology analysis of protein structure, flexibility, and folding,” International journal for numerical methods in biomedical engineering, vol. 30, no. 8, pp. 814–844, 2014. [15] Z. Cang, L. Mu, K. Wu, K. Opron, K. Xia, and G.-W. Wei, “A topological approach for protein classification,” Computational and Mathematical Biophysics, vol. 3, no. 1, 2015. [16] Z. Cang and G.-W. Wei, “Topologynet: Topology based deep convolutional and multitask neural networks for biomolecular property predictions,” PLoS computational biology, vol. 13, no. 7, p. e1005690, 2017. [17] Z. X. Cang and G. W. Wei, “Integration of element specific persistent homology and machine learning for protein-ligand binding affinity prediction,” International journal for numerical methods in biomedical engineering, vol. 34, no. 2, p. e2914, 2018. [18] M. Wang, Z. Cang, and G.-W. Wei, “A topology-based network tree for the prediction of protein–protein binding affinity changes following mutation,” Nature Machine Intelligence, vol. 2, no. 2, pp. 116–123, 2020. [19] J. Chen, R. Wang, M. Wang, and G.-W. Wei, “Mutations strengthened SARS-CoV-2 infectivity,” Journal of molecular biology, vol. 432, no. 19, pp. 5212–5226, 2020. [20] D. D. Nguyen, Z. Cang, K. Wu, M. Wang, Y. Cao, and G.-W. Wei, “Mathematical deep learning for pose and binding affinity prediction and ranking in D3R grand challenges,” Journal of computer-aided molecular design, vol. 33, pp. 71–82, 2019. [21] D. D. Nguyen, K. Gao, M. Wang, and G.-W. Wei, “MathDL: mathematical deep learning for d3r grand challenge 4,” Journal of computer-aided molecular design, vol. 34, pp. 131– 147, 2020. [22] D. D. Nguyen, Z. Cang, and G.-W. Wei, “A review of mathematical representations of biomolecular data,” Physical Chemistry Chemical Physics, vol. 22, no. 8, pp. 4343–4367, 2020. [23] R. Wang, D. D. Nguyen, and G.-W. Wei, “Persistent spectral graph,” arXiv preprint arXiv:1912.04135, 2019. [24] J. Chen, R. Zhao, Y. Tong, and G.-W. Wei, “Evolutionary de Rham-Hodge method,” arXiv preprint arXiv:1912.12388, 2019. [25] R. Wang, D. D. Nguyen, and G.-W. Wei, “Persistent spectral graph,” International Journal for Numerical Methods in Biomedical Engineering, p. e3376, 2020. [26] Z. Meng and K. Xia, “Persistent spectral–based machine learning (PerSpect ML) for protein-ligand binding affinity prediction,” Science Advances, vol. 7, no. 19, p. eabc5329, 2021. [27] J. Wee and K. Xia, “Persistent spectral based ensemble learning (PerSpect-EL) for protein–protein binding affinity prediction,” Briefings in Bioinformatics, p. bbac024, 2022. [28] J. Bi, J. Wee, X. Liu, C. Qu, G. Wang, and K. Xia, “Multiscale Topological Indices for the Quantitative Prediction of SARS CoV-2 Binding Affinity Change upon Mutations,” Journal of Chemical Information and Modeling, vol. 63, no. 13, pp. 4216–4227, 2023. [29] J. Chen, Y. Qiu, R. Wang, and G.-W. Wei, “Persistent Laplacian projected Omicron BA.4 and BA.5 to become new dominating variants,” Computers in Biology and Medicine, vol. 151, p. 106262, 2022. [30] R. Rao, N. Bhattacharya, N. Thomas, Y. Duan, P. Chen, J. Canny, P. Abbeel, and Y. Song, “Evaluating protein transfer learning with TAPE,” Advances in neural information processing systems, vol. 32, 2019. [31] T. Bepler and B. Berger, “Learning protein sequence embeddings using information from structure,” in International Conference on Learning Representations, 2018. [32] E. C. Alley, G. Khimulya, S. Biswas, M. AlQuraishi, and G. M. Church, “Unified rational protein engineering with sequence-based deep representation learning,” Nature methods, vol. 16, no. 12, pp. 1315–1322, 2019. [33] A. Rives, J. Meier, T. Sercu, S. Goyal, Z. Lin, J. Liu, D. Guo, M. Ott, C. L. Zitnick, J. Ma, et al., “Biological structure and function emerge from scaling unsupervised learning to 250 million protein sequences,” Proceedings of the National Academy of Sciences, vol. 118, no. 15, p. e2016239118, 2021. [34] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin, “Attention is all you need,” Advances in Neural Information Processing Systems, vol. 30, 2017. [35] J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova, “BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding,” in North American Chapter of the Association for Computational Linguistics, 2019. [36] J. Meier, R. Rao, R. Verkuil, J. Liu, T. Sercu, and A. Rives, “Language models enable zero-shot prediction of the effects of mutations on protein function,” in Advances in Neural Information Processing Systems (M. Ranzato, A. Beygelzimer, Y. Dauphin, P. Liang, and J. W. Vaughan, eds.), vol. 34, pp. 29287–29303, Curran Associates, Inc., 2021. [37] J. Jumper, R. Evans, A. Pritzel, T. Green, M. Figurnov, O. Ronneberger, K. Tunyasuvunakool, R. Bates, A. Zˇ´ıdek, A. Potapenko, et al., “Highly accurate protein structure prediction with alphafold,” Nature, vol. 596, no. 7873, pp. 583–589, 2021. [38] J. Z. Xiang and B. Honig, “Jackal: A protein structure modeling package,” Columbia University and Howard Hughes Medical Institute, New York, 2002. [39] R. M. Rao, J. Liu, R. Verkuil, J. Meier, J. Canny, P. Abbeel, T. Sercu, and A. Rives, “MSA Transformer,” in International Conference on Machine Learning, pp. 8844–8856, PMLR, 2021. [40] P. Baldi, S. Brunak, Y. Chauvin, C. A. Andersen, and H. Nielsen, “Assessing the accuracy of prediction algorithms for classification: An Overview,” Bioinformatics, vol. 16, no. 5, pp. 412–424, 2000. [41] E. D. Levy, “A simple definition of structural regions in proteins and its use in analyzing interface evolution,” Journal of molecular biology, vol. 403, no. 4, pp. 660–670, 2010. [42] D. S. Goodsell, L. Autin, and A. J. Olson, “Illustrate: Software for biomolecular illustration,” Structure, vol. 27, no. 11, pp. 1716–1720, 2019. [43] Y. Hozumi, K. A. Tanemura, and G.-W. Wei, “Preprocessing of Single Cell RNA Sequencing Data Using Correlated Clustering and Projection,” Journal of Chemical Information and Modeling, 2023. [44] J. R. Munkres, Elements of algebraic topology. CRC Press, 2018. [45] A. J. Zomorodian, Topology for computing, vol. 16. Cambridge university press, 2005. [46] H. Edelsbrunner and J. Harer, Computational topology: an introduction. American Mathematical Soc., 2010. [47] K. Mischaikow and V. Nanda, “Morse theory for filtrations and efficient computation of persistent homology,” Discrete and Computational Geometry, vol. 50, no. 2, pp. 330–353, 2013. [48] D. Horak and J. Jost, “Spectra of combinatorial Laplace operators on simplicial complexes,” Advances in Mathematics, vol. 244, pp. 303–336, 2013. [49] B. Eckmann, “Harmonische funktionen und randwertaufgaben in einem komplex,” Commentarii Mathematici Helvetici, vol. 17, no. 1, pp. 240–255, 1944. [50] A. Zomorodian, “Topological data analysis,” Advances in applied and computational topology, vol. 70, pp. 1–39, 2012. [51] T. G. Project, GUDHI User and Reference Manual. GUDHI Editorial Board, 2015. [52] M. Mirdita, K. Schutze, Y. Moriwaki, L. Heo, S. Ovchinnikov, and M. Steinegger, “Colab- ¨ Fold: Making protein folding accessible to all,” Nature methods, vol. 19, no. 6, pp. 679– 682, 2022. [53] F. Pedregosa, G. Varoquaux, A. Gramfort, V. Michel, B. Thirion, O. Grisel, M. Blondel, P. Prettenhofer, R. Weiss, V. Dubourg, J. Vanderplas, A. Passos, D. Cournapeau, M. Brucher, M. Perrot, and E. Duchesnay, “Scikit-learn: Machine Learning in Python,” Journal of Machine Learning Research, vol. 12, pp. 2825–2830, 2011. [54] T. J. Dolinsky, J. E. Nielsen, J. A. McCammon, and N. A. Baker, “PDB2PQR: An automated pipeline for the setup of Poisson–Boltzmann electrostatics calculations,” Nucleic acids research, vol. 32, no. suppl 2, pp. W665–W667, 2004. [55] B. Liu, B. Wang, R. Zhao, Y. Tong, and G.-W. Wei, “ESES: Software for eulerian solvent excluded surface,” 2017. [56] D. Chen, Z. Chen, C. Chen, W. Geng, and G.-W. Wei, “MIBPB: A software package for electrostatic analysis,” Journal of computational chemistry, vol. 32, no. 4, pp. 756–770, 2011. [57] H. Li, A. D. Robertson, and J. H. Jensen, “Very fast empirical prediction and rationalization of protein pKa values,” Proteins: Structure, Function, and Bioinformatics, vol. 61, no. 4, pp. 704–721, 2005. [58] M. Johnson, I. Zaretskaya, Y. Raytselis, Y. Merezhuk, S. McGinnis, and T. L. Madden, “NCBI BLAST: A better web interface,” Nucleic acids research, vol. 36, no. suppl 2, pp. W5–W9, 2008. [59] R. Heffernan, K. Paliwal, J. Lyons, A. Dehzangi, A. Sharma, J. Wang, A. Sattar, Y. Yang, and Y. Zhou, “Improving prediction of secondary structure, local backbone angles and solvent accessible surface area of proteins by iterative deep learning,” Scientific reports, vol. 5, no. 1, p. 11476, 2015. [60] C. Maria, J.-D. Boissonnat, M. Glisse, and M. Yvinec, “The GUDHI library: Simplicial complexes and persistent homology,” in Mathematical Software–ICMS 2014: 4th International Congress, Seoul, South Korea, August 5-9, 2014. Proceedings 4, pp. 167–174, Springer, 2014. This paper is under CC 4.0 license. available on arxiv Lead image by Cytonn Photography on Unsplash

Contributing Partners: NIH, NSF, NASA, and More Back TopLapGBT's Advancements

Authors: (1) JunJie Wee, Department of Mathematics, Michigan State University; (2) Jiahui Chen, Department of Mathematical Sciences, University of Arkansas; (3) Kelin Xia, Division of Mathematical Sciences, School of Physical and Mathematical Sciences Nanyang Technological University & xiakelin@ntu.edu.sg; (4)Guo-Wei Wei, Department of Mathematics, Michigan State University, Department of Biochemistry and Molecular Biology, Michigan State University, Department of Electrical and Computer Engineering, Michigan State University & xiakelin@ntu.edu.sg. Table of Links Abstract & Introduction Results Discussion Conclusion Materials and Methods Software and resources, Code and Data Availability Supporting Information, Acknowledgments & References 6 Software and resources Protein sequences are first preprocessed by AlphaFold 2 to generate wild type protein structures. In particular, 3D protein structures are generated from protein sequences using ColabFold [52]. Mutant proteins are generated from the Jackal software[38]. All TopLapGBT models are built using the sklearn machine learning library [53]. The hyperparameters for all the TopLapGBT are: n estimators = 20000, learning rate = 0.05, max depth = 7, subsample=0.4, min sample split = 3 and max features = sqrt. The PQR files, which contains the partial charge information of the proteins, are generated from the PDB2PQR software [54]. The PQR files for both the wild type proteins are generated with AMBER force field. The solvation energy and surface area information are calculated from the in-house online software package ESES [55] and MIBPB [56]. The pKa values are computed from the PROPKA software package [57]. The position-specific-scoring matrices (PSSM) are computed from the BLAST+ software [58] using the nr database. The secondary structure features and torsion angle sequence-based information are calculated from SPIDER [59]. The persistent Laplacian descriptors for both VR complexes and alpha complexes are calculated using the GUDHI software library [60]. All computational work in support of this research was performed using the resources from the National Super Computing Centre of Singapore (NSCC). Code and Data Availability The 3D protein structures and the TopLapGBT code can be found in https://github.com/ExpectozJJ/TopLapGBT. The source code for the R-S plot can be found at https://github.com/hozumiyu/RSI. This paper is under CC 4.0 license. available on arxiv

Stories, News & Mentions about NAYYA

Nayya’s Stories on HackerNoon