Former House Speaker Nancy Pelosi, D-Calif., was evicted from her private Capitol office by the new speaker pro-tempore. Fox News Digital confirmed that House Speaker pro-tempore Patrick McHenry ...

Nancy Pelosi evicted from her private office in the Capitol by interim House speaker

What do time builders, experience builders, and flight instructors have in common? They all work at flight schools, but only two of them can teach you how to fly. Flight instructors have chosen to ...

Death by Time Builder

Universal Music and BandLab have announced an alliance around AI, stating that they will “pioneer market-led solutions with pro-creator standards to ensure new technologies serve the creator community

Universal and BandLab announce alliance around AI

Universal Music Group and BandLab have forged an alliance to help protect artists rights as the use of artificial intelligence continues to rise. The main aim of the partnership is to prevent AI from overstepping

Universal Music Group, BandLab Technologies Join Forces for Artists’ Rights Against AI

We independently review everything we recommend. When you buy through our links, we may earn a commission. Learn more› After a new round of testing, we have a number of new picks for just about ...

The Best Car Phone Mount

Universal Music Group (UMG), the world leader in music-based entertainment, and BandLab Technologies, the parent company of the world’s largest social music creation platform, BandLab, today

UMG and Bandlab Form Strategic Relationship On Artificial Intelligence (AI)

Universal Music Group, the label representing Taylor Swift, said on Wednesday it has partnered with digital music firm BandLab Technologies to help protect the rights of artists and songwriters amid the growing use of artificial intelligence.

Universal Music, BandLab Technologies team up to protect artist rights amid rising AI use

Universal Music Group (UMG) and BandLab Technologies, the parent company of social music creation platform BandLab, have announced what they call “an expansive, industry-first strategic relationship concentrated on artificial intelligence.

BandLab Technologies & Universal Music Group Announce AI Partnership

(Reuters) – Universal Music Group, the label representing Taylor Swift, said on Wednesday it has partnered with digital music firm BandLab Technologies to help protect the rights of artists and songwriters amid the growing use of artificial intelligence.

Universal Music, BandLab team up to protect artist rights amid rising AI use

Cakewalk by BandLab

bandlab

Most of Angular developers including me have some back-end programming background. It has some advantages but it has also some implications on fact, how we solve certain problems. We see world as bunch of objects which are containers for responsibilities. In redux you have to switch your mindset a bit. Do not fight with boilerplate. When I started with redux I hated these action creators and this big and ugly switch statement. So I started with defining some conventions inspired by alt.js implementation. Then I have implemented something like below SavedConfigurationStore { export class (state, _, busy) {**return ** {...state, busy);} setBusy (state) { ...state, invalidate**: true}**;} invalidate return { (state, action) { action.payload, invalidate**: false**};} onFetchSavedConfigsSuccess return {... : state, configs .... } savedStore SavedConfigurationStore(); savedConfigurationReducer ReducerBinder. (). (SavedActions, savedStore). (SavedActions. , savedStore. ) const = new export const = start bindActionsByConvention bindAsyncAction FETCH_SAVED_CONFIGS setBusy I created that just to have nice simple POJO objects with actions. Then i defined this ReducerBinder class to bind my object methods as action handlers. However it make look more appealing for back-end developer, it has a lot of downsides. Nobody except me know this convention, if I will force my team mates to build whole application based on this redux wrapper they quickly gonna hate me. Secondly it uses OO patterns. Redux is about using functional approach, to have everything divided into small composable functions. In above example we have everything in one big object. This boilerplate which redux is coming with has more advantages than downsides. You have full control. You will be truly surprised, how easy with that architecture it will be, to implement offline state, redo/undo functionality, optimistic update functionality and many more. There is no reason to fight with that. If you wanna have full control over your code you don’t wanna cover everything with abstraction. Normalize your state You should keep your reducers relatively small and compact. When your state is not normalized and you are keeping everything inside one big model, it will end up with big mess. In your reducer you will have whole bunch of tools from lodash just to traverse these big tree of objects and find one you wanna update. When you finally find leaf object, you wanna update you need to create new object for each parent of that object up to the root of your model. initialState {genres**:** [{id**:** 1, name**:** , bands**:** [{id**:** 1, name**:** , albums**:** [{id**:** 1, name**:** , items**:** 3},{id**:** 2, name**:** , items**:** 66},{id**:** 3, name**:** , items**:** 3},]},{id**:** 2, name**:** },]}]}; const = 'rock' 'led zeppelin' 'I' 'II' 'III' 'boston' (state = initialState, { , payload}) { ( ) { UPDATE_ITEMS_COUNT**:const** nextGenres state.genres. (g { nextBands g.bands. (b { b.albums. (a { (a.id payload.id) { a;} {...a, items**:** payload.items};});}); {...g, bands**:** nextBands}}); export const albums = type => switch type case = map => const = map => return map => if != return return return **return** {...state, genres**:** nextGenres};  
**default:  
  return** state }}; That’s how your code will be looking like. When you will normalize your sate you will have three reducers: genres, bands, albums. Your responsibility will be distributed properly. Albums reducer will be responsible for performing updates on album models. Genres and bands reducers can be responsible for moving albums around from one group to another. initialState {[1] {id**:** 1, name**:** , items**:** 3},[2] {id**:** 2, name**:** , items**:** 66},[3] {id**:** 3, name**:** , items**:** 3}}; const = : 'I' : 'II' : 'III' (state initialState, { , payload}) { ( ) { UPDATE_ITEMS_COUNT**:const** {id, items} payload; album state[id]; {...state, [id] {...album, items}}; state}}; export const albums = = type => switch type case = const = return : default:return Above you can look how normalized reducer looks like. It’s worth to notice that you not only have flat structure but you only keep all object on “dictionary” instead of keeping everything on array. When you have dictionary with keys as ids it’s much easier to find object for update. How can i normalize state? It can be done manualy inside your service class implementation. Or you can use third party libraries that helps with that. I higly recommend to take a look on library. With normlizr you are defining schema data retrieved from server liek below: normalizr import { normalize, schema } from 'normalizr'; const album = new schema.Entity('album');const bands = new schema.Entity('bands', {albums: [album]});const genres = new schema.Entity('genres', {bands: [ bands]}); const normalizedData = normalize(originalData, genres); and result will be like below a {result**:** ,entities**:** { { {id**:** 1, name**:** , bands**:** [1, 2]}}, { {id**:** 1, name**:** , items**:** 3}, {id**:** 2, name**:** , items**:** 3}, {id**:** 3, name**:** , items**:** 3}}, { {id**:** , name**:** , albums**: :** {id**:** , name**:** , albums**:** []},}}}; var = "123" "genres" : "123" : 'rock' "albums" : "1" : 'I' "2" : 'I' "3" : 'I' "bnads" : "1" : "1" 'led zeppelin' [ , , ]}, "1" "2" "3" "2" "1" 'boston' How to denormalize state for views? However normalization is simplifying updates operations, it makes reads bit more complex. But it also gives you more flexibility. When one of your view needs join from two entities and other view needs join from 3 other entities, then you can do this relatively easy. It also have good impact on your performance. When your view needs as view model only 2 entities and you are updating 3rd one, then your view is not being refreshed unnecessary. But you have to use onPush notification mode and you have to denormalize data for view model smartly. I was looking for some advices for that and didn’t find anything helpful so i made my way of denormalization sate. If someone has better approach for that please let me know. Let’s say we wanna have view that presents our data in exact same shape as initial model was: <div class="genre"  *ngFor="let genre of genres"><div class="band" *ngFor="let band of genre.bands"><div class="album" *ngFor="let album of band.albums">{{genre.name}}{{band.name}}:{{album.name}}</div><img  [attr.src]="album.coverImage" /></div></div> Right now we cannot do this because our model is normalized. For example genre model has only list of bands ids. We can achieve that by defining some mapping selectors like below: state**=> => =>** { band bands[bid]; bandAlbums band.albums.map(aid**=> :** bandAlbums};})})}; const getGenres = { {albums, genres, bands} state.entities; values(genres).map(g const = return { bands g.bands.map(bid const = const = const = { a albums[aid]; {...a, coverImage ${a.name} }}); {...band, albums const = return : `images/ .jpg` return store.select( ). ((g) { .genres g;}) getGenres subscribe => this = But i wouldnt recommend you doing that becasue of two reasons: we are mixing here two concerns — traversing object tree and mapping to view model. every time one single album will be updated, angular will recreate whole tree of view models as new instances which will cause re-render for whole thing, even if we are using onPush strategy. To bust performance and divide responsiblity we can do something like below: @Component({template**:** _`<div class="genre"  *ngFor="let genre of (genres$|async)"><genre-view [genre]="gendre"></genre-view></div>`_}) HomeComponent {genres$; export class (store**:** Store**< >**) { .genres$ .store. (getAllGenres);}} constructor AppState this = this select then inside GenreComponent we have code like below @Component({selector**:** ,template**:** _`<div class="band" *ngFor="let band of (bands$|async$)"><band-view [band]="band" [genre]="genre"></band-view></div>`_}) GenreComponent {@Input() genre;bands$; (store**:** Store**< >**) { .bands$ .store. (getBandsByIds( .genre.bands))}} 'genre-view' export class constructor AppState this = this select this and then inside BandComponent @Component({selector**:** ,template**:** }))}} 'band-view' `<div class="album" *ngFor="let album of (albums$|async)">{{genre.name}}{{band.name}}:{{album.name}}<img  [attr.src]="album.coverImage" /></div>` .jpg` }) BandComponent {@Input() genre;@Input() band;albums$; (store**:** Store**< > => :** a.name,coverImage**:** ${a.name} export class constructor AppState ) { .albums$ .store. (getAlbumsByIds( .band.ablums)). (a this = this select this map ({name ` So far so good. But there are two problems with that solution. We are not fully getting benefit from OnPush change detection strategy. Second thing is that, we are defining list of children only once inside constructor, which means when input parameter will change we are not reacting at all. When BandComponent band input will change, it will be still rendering albums which belongs to previous band. To fix that my approach is like below. @Component({selector**:** ,changeDetection**:** ChangeDetectionStrategy. ,template**:** })). (a**=> :** a};cd. ();}); 'band-view' OnPush `<div class="album" *ngFor="let album of props.albums">{{album.name}}<img  [attr.src]="album.coverImage" /></div>` .jpg` }) BandComponent {@Input() band;band$ Subject**< > :** Store**< > => :** a.name,coverImage**:** ${a.name} export class = new any ();props {}; (store = constructor AppState , cd ChangeDetectorRef) { .store.let( ( .band$)).map(a private : this queryBandAlbums this ({name ` subscribe { .props {albums this = markForCheck } (){ .band$. ( .band);}} onChanges this next this band$ store$ { band$.switchMap(b store$. (getAlbumsByIds(b.ablums))).distinctUntilChanged();}; export const queryBandAlbums = => => return => select We are using Angular onChanges life cycle hook to monitor every change of input parameter. Every time band parameter will change, we will get new list of albums We are using OnPush change detection strategy to gain better performance. However with this strategy angular will know nothing if album object will change itself. Because of that we need to inform angular with cd.markForCheck() about changes. With that approach we have best from two worlds. We have nice normalized data, which is easy to deal with. We have good performance because when something will change, inside only one album, then only this element will be re-rendered. All other references will remain the same. Let me know if you have better approach how to deal with normalized state with Angular.

What I have learned using ngrx/Redux with Angular 2

Authors:
(1) Aarav Patel, Amity Regional High School – email: aarav.;
(2) Peter Gloor, Center for Collective Intelligence, Massachusetts Institute of Technology and Corresponding author – email: . Table of Links Abstract and Introduction
Related Works
Purpose
Methods
Results
Discussion
Conclusion and Bibliography 6. Discussion The Random Forest Regression Model likely performed the best because it works by combining the predictions of multiple decision trees. This allows it to improve its accuracy and reduce overfitting to one specific tree, thus producing superior results. The Random Forest Regression algorithm had a statistically significant R2 Correlation of 26.1% (p-value <0.05), and it had a low MAAE of 13.4%. These results align with similar work done using other sources of data (Krappel et al., 2021). For example, a paper by Krappel et al. created an ESG prediction system by feeding fundamental data (i.e., financial data and general information surrounding the company) into ensemble machine-learning algorithms. Their most accurate model received an R2 correlation of 54% and a MAAE of 11.3%. While the proposed algorithm does not correlate as well as Krappel et al.’s model, likely because it leverages qualitative data, it still highlights the viability of using social sentiment as a proxy for ESG. The proposed algorithm displayed encouraging results, highlighting its viability in ESG rating prediction. Unlike current ESG raters who determine ESG using self-disclosed sustainability reports, the proposed algorithm’s data-driven approach allows for a more holistic and balanced evaluation. Utilizing social sentiment also allows executives to measure which areas people want a company to improve on, helping to focus actions on change Additionally, the system’s architecture allows for scores to be updated within short timeframes. Finally, executives can test additional keywords by inputting them into the algorithm. These attributes showcase the system’s flexibility as well as advantages over the conventional methodology. A limitation of the results, however, is that it was tested on the S&P 500 companies. Therefore, results might not carry over for smaller companies below this index. Another limitation could be misinformation within the social network data. While this should be diluted by other comments, it can potentially alter the algorithm’s ratings. Additionally, the Flair sentiment analysis algorithm sometimes misclassified post/article sentiment, especially if the post/article had a sarcastic attitude. Finally, for this research, access to certain paid native APIs was not available. As a result, the collected data might not encompass all data available for a keyword due to rate limiting. While the algorithm has displayed statistically significant results, there is room for improvement that can be done in future research. Some of this can include gathering more data. This can be done by analyzing more companies beyond the S&P 500 or by collecting data for more keywords and ESG sub-topics. This can also be done by using native APIs to collect more datapoints per individual keyword. Additionally, more data sources could be incorporated into the model. This can be done by incorporating other social networks (i.e., Reddit, Glassdoor) or by including quantitative data/statistics (i.e., % women as board members, number of scope 1 carbon emissions, etc.) from company reports and government databases. Furthermore, to better fit the task at hand, NLP algorithms can be created specifically for ESG. For instance, while the current method filters much of the irrelevant data, some unrelated data still gets through. So, to solve this, a new supervised learning algorithm can be trained to identify related bodies of text using TF-IDF vectorization. The algorithm can be trained by handlabeling the data that has already been collected. To add on, the long-article/short-post NLP algorithms can also be further optimized. While Flair can already provide satisfactory results, some articles seem to be misclassified, which might be a source of error for the algorithm. By creating a sentiment analysis algorithm specifically tailored to ESG classification, the long-article and short-post NLP algorithm accuracy can be further improved. This can be done by either creating a custom ESG lexicon with weights or by training a novel NLP algorithm against classified ESG data. Finally, another area to be improved is post credibility: While small amounts of misinformation would not significantly alter results, it is still best to mitigate this risk as much as possible. There is a growing body of literature that explores fake news identification on social networks. So, these approaches can potentially be used to identify fake posts/articles (de Beer et al., 2020). Also, adding “hard” quantitative data from company filings to the algorithm can be used as an added safeguard. Finally, the algorithm can prioritize more centralized/credible actors over others to yield safer outputs. Overall, this research provides a proof-of-concept framework for a social-network-based ESG evaluation system. This work can serve as the backend logic for a social sentiment ESG product which can eventually be used by executives. While pre-packaged libraries were used for prototyping purposes, in future works, these aspects of the project can be optimized. Unlike existing frameworks that rely on self-reported company filings, the proposed models take on a more balanced view of the company’s ESG positives and negatives. In general, this can help approach an ESG ground truth that can better influence company practices to be more sustainable. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. Authors: (1) Aarav Patel, Amity Regional High School – email: aarav.; (2) Peter Gloor, Center for Collective Intelligence, Massachusetts Institute of Technology and Corresponding author – email: . Authors: Authors: (1) Aarav Patel, Amity Regional High School – email: aarav.; (2) Peter Gloor, Center for Collective Intelligence, Massachusetts Institute of Technology and Corresponding author – email: . Table of Links Abstract and Introduction Related Works Purpose Methods Results Discussion Conclusion and Bibliography Abstract and Introduction Abstract and Introduction Related Works Related Works Purpose Purpose Methods Methods Results Results Discussion Discussion Conclusion and Bibliography Conclusion and Bibliography 6. Discussion The Random Forest Regression Model likely performed the best because it works by combining the predictions of multiple decision trees. This allows it to improve its accuracy and reduce overfitting to one specific tree, thus producing superior results. The Random Forest Regression algorithm had a statistically significant R2 Correlation of 26.1% (p-value <0.05), and it had a low MAAE of 13.4%. These results align with similar work done using other sources of data (Krappel et al., 2021). For example, a paper by Krappel et al. created an ESG prediction system by feeding fundamental data (i.e., financial data and general information surrounding the company) into ensemble machine-learning algorithms. Their most accurate model received an R2 correlation of 54% and a MAAE of 11.3%. While the proposed algorithm does not correlate as well as Krappel et al.’s model, likely because it leverages qualitative data, it still highlights the viability of using social sentiment as a proxy for ESG. The proposed algorithm displayed encouraging results, highlighting its viability in ESG rating prediction. Unlike current ESG raters who determine ESG using self-disclosed sustainability reports, the proposed algorithm’s data-driven approach allows for a more holistic and balanced evaluation. Utilizing social sentiment also allows executives to measure which areas people want a company to improve on, helping to focus actions on change Additionally, the system’s architecture allows for scores to be updated within short timeframes. Finally, executives can test additional keywords by inputting them into the algorithm. These attributes showcase the system’s flexibility as well as advantages over the conventional methodology. A limitation of the results, however, is that it was tested on the S&P 500 companies. Therefore, results might not carry over for smaller companies below this index. Another limitation could be misinformation within the social network data. While this should be diluted by other comments, it can potentially alter the algorithm’s ratings. Additionally, the Flair sentiment analysis algorithm sometimes misclassified post/article sentiment, especially if the post/article had a sarcastic attitude. Finally, for this research, access to certain paid native APIs was not available. As a result, the collected data might not encompass all data available for a keyword due to rate limiting. While the algorithm has displayed statistically significant results, there is room for improvement that can be done in future research. Some of this can include gathering more data. This can be done by analyzing more companies beyond the S&P 500 or by collecting data for more keywords and ESG sub-topics. This can also be done by using native APIs to collect more datapoints per individual keyword. Additionally, more data sources could be incorporated into the model. This can be done by incorporating other social networks (i.e., Reddit, Glassdoor) or by including quantitative data/statistics (i.e., % women as board members, number of scope 1 carbon emissions, etc.) from company reports and government databases. Furthermore, to better fit the task at hand, NLP algorithms can be created specifically for ESG. For instance, while the current method filters much of the irrelevant data, some unrelated data still gets through. So, to solve this, a new supervised learning algorithm can be trained to identify related bodies of text using TF-IDF vectorization. The algorithm can be trained by handlabeling the data that has already been collected. To add on, the long-article/short-post NLP algorithms can also be further optimized. While Flair can already provide satisfactory results, some articles seem to be misclassified, which might be a source of error for the algorithm. By creating a sentiment analysis algorithm specifically tailored to ESG classification, the long-article and short-post NLP algorithm accuracy can be further improved. This can be done by either creating a custom ESG lexicon with weights or by training a novel NLP algorithm against classified ESG data. Finally, another area to be improved is post credibility: While small amounts of misinformation would not significantly alter results, it is still best to mitigate this risk as much as possible. There is a growing body of literature that explores fake news identification on social networks. So, these approaches can potentially be used to identify fake posts/articles (de Beer et al., 2020). Also, adding “hard” quantitative data from company filings to the algorithm can be used as an added safeguard. Finally, the algorithm can prioritize more centralized/credible actors over others to yield safer outputs. Overall, this research provides a proof-of-concept framework for a social-network-based ESG evaluation system. This work can serve as the backend logic for a social sentiment ESG product which can eventually be used by executives. While pre-packaged libraries were used for prototyping purposes, in future works, these aspects of the project can be optimized. Unlike existing frameworks that rely on self-reported company filings, the proposed models take on a more balanced view of the company’s ESG positives and negatives. In general, this can help approach an ESG ground truth that can better influence company practices to be more sustainable. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. available on arxiv

Stories, News & Mentions about BANDLAB

Bandlab’s Stories on HackerNoon

Bandlab's News & Mentions