Illegal transactions detection model to prevent money laundering
Money laundering is a multi-billion-dollar issue. Detection of laundering is very difficult. Banks and regulatory authorities struggle to identify these illegal transactions. Not only does it cost them billions in unpaid taxes, but it also promotes crime at the cost of socioeconomic health of a country.
There exist many automated algorithms which aim to detect illegal transactions but most of them have a high false positive rate: legitimate transactions are incorrectly flagged as laundering. The converse is also a major problem --false negatives, i.e. undetected laundering transactions. Naturally, criminals work hard to cover their tracks.
The aim of this module is to utilise IBM’s synthetic dataset of over 10 lakh financial transactions to create a deep learning model for fraud detection. The dataset, which is available on the Kaggle repository, is based on a virtual world inhabited by individuals, companies, and banks. Individuals interact with other individuals and companies. Likewise, companies interact with other companies and with individuals. These interactions can take many forms, e.g. purchase of consumer goods and services, purchase orders for industrial supplies, payment of salaries, repayment of loans, and more. These financial transactions are generally conducted via banks. Using a combination of supervised learning, deep learning, and GridSearchCV assisted models, this module will aim to achieve at least 90% accuracy in identifying illegal transactions.
To organise the money laundering dataset and test it with basic prediction models
Aim: This dataset, consisting of over 10 lakh banking transactions, is semi-organised. The purpose of this goal is to organise and clean it, understand its general characteristics, deduce new information from the data, and create basic prediction models using supervised learning methods like SVM (Support Vector Machines), Naïve Bayes, Logistic Regression, and Random Forest.
Method: Python programming language will be used to:
- Create bar/ pie charts
- Create new features of the dataset
- Clean and organise the data
- Build prediction models
To contribute and publish select a pending milestone.
There are no completed milestones.
- 1000 words
- unpaid
- 1 day later
- No files attached
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here.
In order to create different prediction models to identify illegal transactions, the first step is to understand the characteristics of the dataset. The purpose of this milestone is to use Python to create frequency tables and charts to assess the number of payments received and made, payment status and currency. This is a part of ‘exploratory analysis’ i.e., simple functions in Python.
Method: Use the Python application (Jupyter Notebook) and follow the below steps.
- Go through the dataset and understand it.
- Create a bar chart to define the frequency of transactions from each bank,
- Create a bar chart to define the frequency of transactions to which bank
- Create a bar chart for ‘receiving current’
- Create a bar chart for ‘payment current’
- Create a pie chart for defining payment format
- Create a pie chart for defining laundering status
- Create a frequency table to show the number of transactions for each currency
Structure: after generating all the charts and table, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Introduction to the dataset
- Explanation of the bar chart ‘frequency of transactions from each bank’
- Explanation of the bar chart ‘frequency of transactions to which bank’
- Explanation of the bar chart ‘receiving current’
- Explanation of the bar chart ‘payment current’
- Explanation of the pie chart ‘defining payment format’
- Explanation of the bar chart ‘defining laundering status’
- Conclusion
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb) for charts and graphs
- Size 1000 words
- Type unpaid
- Deadline 1 day later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here.
Although the ultimate goal of this study is to create a different prediction model to detect illegal transactions, the first step is to understand the characteristics of the dataset. The purpose of this milestone is to use Python to create pie charts to distribute the amounts received and amounts paid according to a range. This is a part of ‘exploratory analysis’ i.e., simple functions in Python.
Methodology: Use the Python application (Jupyter Notebook) and follow the below steps.
- Go through the dataset and understand it.
- Create a pie chart for distributing the ‘payments received’ column into the following ranges:
- Below 50000
- 50000-100000
- 1000000-5000000
- 5000000-10000000
- 10000000-50000000,
- Above 50000000
- Create a pie chart for the ‘payments made’ in the same ranges.
Structure: after generating all the charts and table, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Introduction to the dataset
- Explanation of the pie chart ‘payments received’.
- Explanation of the pie chart ‘payments made’.
- Conclusion
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here.
Although the ultimate goal of this study is to create a different prediction model to detect illegal transactions, the first step is to understand the characteristics of the dataset. The purpose of this milestone is to use Python to create new features in this dataset like generating the mean values. This is a part of ‘feature extraction’ i.e., intermediate-level functions in Python.
Methodology: Use the Python application (Jupyter Notebook) and follow the below steps.
- Go through the dataset and understand it.
- Based on different currency types, define a new feature for recording the aggregate of the mean of ‘received’ and ‘paid’ amounts. For example- you compute the mean of ‘paid’ amounts for the US dollar, similarly for Euro, and so on.
- Based on the frequency of transactions between the two accounts, add a new feature of aggregate number of transactions, i.e., wherein the if recipient account has more than 50 transactions, then the value is ‘1’, else ‘0’.
Structure: after generating all the charts and table, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Introduction to the dataset
- Explanation of the ‘mean’ feature which you generated.
- Explanation of the ‘aggregate number of transactions’ feature which you generated
- Conclusion
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here.
Although the ultimate goal of this study is to create a different prediction model to detect illegal transactions, the first step is to clean and organise the dataset. The purpose of this milestone is to clean the data to make it relevant for model building at a later stage. This is a part of ‘data preprocessing’ i.e., intermediate-level functions in Python.
Methodology: Use the Python application (Jupyter Notebook) and follow the below steps.
- Transform the Timestamp using normalization.
- Create a Unique ID for each transaction by adding bank code with the account number.
- Create a new dataframe for recording all receiving information like receiving amount, currency, and account.
- Create a separate dataframe for recording all the payment information like paid amount, currency, and account.
- Create a list of currencies which are used for all transactions.
- Using labelencoder, label the receiving currency, payment currency, and the payment format
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Introduction to/ Characteristics of the dataset
- Process of transforming timestamp (explain in a few simple steps)
- Process of creating a UniqueID for each transaction (explain in a few simple steps)
- Process of creating a new dataframe for recording RECEIVED AMOUNTS information (explain in a few simple steps)
- Process of creating a separate dataframe for recording PAID AMOUNTS information (explain in a few simple steps)
- Process of creating a list of currencies (explain in a few simple steps)
- Process of labelling the currency and payment format (explain in a few simple steps)
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Intermediate’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using SVM with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a SVM based model for prediction.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Intermediate’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using Naïve Bayes with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a Naïve Bayes based model for prediction.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Intermediate’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a Logistic Regression based model for prediction.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Intermediate’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using KNN with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a KNN based model for prediction.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Intermediate’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using Random Forest with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a Random Forest based model for prediction.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Intermediate’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using Decision Tree with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a Decision Tree based model for prediction.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Advanced’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using LSTM with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a LSTM based model for prediction.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Advanced’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using Bi-LSTM with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a Bi-LSTM based model for prediction.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Advanced’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using CNN with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a CNN based model for prediction.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Advanced’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using ANN with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a ANN based model for prediction.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 1 day later
- No files attached
Aim: To conduct descriptive statistics and correlation analysis on the financial transactions dataset to understand key characteristics and relationships among variables.
Methodology: Use the Python application (Jupyter Notebook) to perform the following:
- Complete milestones “Understanding the nature of banks’ financial transactions using Python”, “Using Python to classify financial transaction data according to amount”, and “Cleaning financial transactions dataset using Python”
- Summarize the dataset using descriptive statistics (mean, median, standard deviation, range) for all variables
- Calculate the correlation matrix to identify relationships among numeric variables.
- Use heatmaps to visualize correlations, focusing on the strength and direction (positive/negative) of relationships.
Structure: Write a 1000-word article in the following format:
- Brief overview of money laundering and its implications for the financial sector.
- Importance of understanding dataset characteristics through descriptive analysis particularly in detecting anomalies in financial transactions.
- Highlight key statistics derived from the dataset and conclude what they represent about the financial transactions
- Discuss findings from the correlation matrix and visualizations.Identify any highly correlated variables that may indicate multicollinearity.
- Summarize insights gained from descriptive and correlation analyses, linking back to the context of money laundering.
Submission:
Article in MS Word format, Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 1 day later
- For all
- 1000 words
- unpaid
- 1 day later
- No files attached
Aim: To conduct assumption testing for regression analysis using the financial transactions dataset, ensuring the model's validity.
Methodology: In this milestone, we will specify the variables used in our analysis and their interrelationships. The final list of variables would be ‘Is_Laundering’, 'Timestamp', 'From Bank', 'Account', 'To Bank', 'Account.1', 'Amount Received', 'Receiving Currency', 'Amount Paid', 'Payment Currency', 'Payment Format', and 'Transaction_ID'. The dependent variable will be Is_Laundering, a binary variable indicating whether a transaction is suspected of being linked to money laundering (1) or not (0). The independent variables include 'Timestamp', 'From Bank', 'Account', 'To Bank', 'Account.1', 'Amount Received', 'Receiving Currency', 'Amount Paid', 'Payment Currency', 'Payment Format', and 'Transaction_ID'. The nature of the linkage between the dependent and independent variables will be assessed through regression analysis, focusing on how changes in the independent variables influence the likelihood of a transaction being flagged as potentially illegal. For example, we anticipate that higher amounts received or paid may correlate with a higher likelihood of being flagged as suspicious, while certain transaction types may also significantly influence this outcome.
To ensure the validity of our regression model, we will conduct several assumption tests:
- Independence of Observations: We will check for autocorrelation in residuals using the Durbin-Watson test.
- Linearity: The linearity between independent variables and the dependent variable will be assessed using scatter plots and correlation coefficients to visualize relationships.
- Homoscedasticity: We will check for constant variance of residuals using Breusch-Pagan test . Residuals plots will also be utilized to visualize homoscedasticity.
- Normality of Residuals: We will assess the normality of residuals using the Shapiro-Wilk test and Q-Q plots to determine if the residuals are normally distributed.
- Multicollinearity: We will evaluate multicollinearity among independent variables by calculating the Variance Inflation Factor (VIF) and analyzing the correlation matrix to identify any highly correlated variables that could adversely affect the model.
Structure: Write a 1000-word article in the following format:
- Introduction
- Discuss the significance of verifying assumptions for OLS regression in the context of detecting money laundering.
- Explain the purpose of each assumption and the tests used to validate them.
- Present results of linearity, independence, homoscedasticity, normality, and multicollinearity tests.
- Summarize insights gained from assumption testing and and its implications for detecting money laundering.
Submission:
Article in MS Word format, Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 1 day later
- For all
- 1000 words
- unpaid
- 1 day later
- No files attached
Aim: To conduct OLS regression analysis on the financial transactions dataset, modeling the relationship between independent variables and the dependent variable.
Methodology:
In this milestone, we will develop an Ordinary Least Squares (OLS) regression model to analyze the financial transactions dataset. The dependent variable will be Is_Laundering, a binary variable indicating whether a transaction is suspected of being linked to money laundering (1) or not (0). The independent variables include 'Timestamp', 'From Bank', 'Account', 'To Bank', 'Account.1', 'Amount Received', 'Receiving Currency', 'Amount Paid', 'Payment Currency', 'Payment Format', and 'Transaction_ID'.
Before fitting the OLS model, we will ensure that all assumptions outlined in the previous milestone (Milestone 6) are satisfied. Once confirmed, we will proceed with the model fitting using Python’s statsmodels library, which provides tools for estimating the parameters of the regression equation. We will interpret the coefficients of the regression output to assess the direction and strength of the relationships between the independent variables and the dependent variable. Specifically, we will analyze the significance of each variable using p-values and confidence intervals.
After fitting the model, we will evaluate its performance using various metrics, including Mean Squared Error (MSE) and R-squared. MSE will provide insight into the average squared difference between the predicted and observed values, while R-squared will indicate the proportion of variance in the dependent variable explained by the independent variables. Additionally, we will visualize the results using residual plots to assess the fit of the model and ensure no patterns exist in the residuals, which would suggest model inadequacy.
Finally, we will document our findings and interpretations in a detailed report, discussing the implications of the OLS model results in relation to money laundering detection. This will include a summary of which factors significantly influence the likelihood of transactions being flagged and any insights that could inform future predictive modeling efforts.
Structure: Write a 1000-word article in the following format:
- Role of selected variables in influencing the money laundering
- Importance of OLS regression in the context of money laundering detection.
- Present and interpret regression output
- Present MSE and R-squared results and their significance in understanding money laundering patterns.
- Summarize insights and theoretical implications for money laundering detection.
Submission:
Article in MS Word format, Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 1 day later
- For all
- 1000 words
- unpaid
- 1 day later
- No files attached
Aim: To perform Principal Component Analysis (PCA) on the financial transactions dataset to reduce dimensionality and extract significant features.
Methodology: PCA is a statistical technique used to transform a high-dimensional dataset into a lower-dimensional space while preserving as much variance as possible. The theoretical framework of PCA is grounded in its ability to reveal hidden structures in data that may correlate with money laundering. High-dimensional financial data can contain redundant information, and PCA helps in identifying the underlying factors that contribute to variability, potentially indicating laundering activities.
In this milestone, we will apply PCA to our dataset, focusing on variables related to financial transactions, such as 'Timestamp', 'From Bank', 'Account', 'To Bank', 'Account.1', 'Amount Received', 'Receiving Currency', 'Amount Paid', 'Payment Currency', 'Payment Format', and 'Transaction_ID'. The aim is to reduce dimensionality while retaining maximum variability in the data.
We will use pre-processed data to perform PCA using Python’s scikit-learn library, extract the principal components, and evaluate the explained variance ratio to determine how many components to retain. Insights gained from PCA will help in identifying transaction patterns that are indicative of money laundering risks.
Structure: Write a 1000-word article in the following format:
- Discuss the significance of PCA in data analysis and its theoretical basis in the context of detecting money laundering.
- Explain the steps involved in applying PCA and the rationale behind each step, highlighting the relevance of identified components to money laundering.
- Present the principal components and their explained variance, discussing the implications of these findings for understanding money laundering patterns.
- Summarize the insights gained from PCA and its relevance to detecting money laundering.
Submission: Article in MS Word format, Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 1 day later
- For all
To build an optimized illegal transactions detection model which reduces false positives
Purpose: Existing models for detecting illegal/ fraudulent banking transactions are many. However the problem of false positives i.e., illegal transactions being identified as legitimate and vice versa. This causes not only financial losses for the bank but also fails to address the mammoth problem of money laundering. The purpose of this goal is to create an optimised illegal transactions detection model by using deep learning methods.
Method: We will use optimised deep learning models including GridSearchCV process on Python (JupyterNotebook).
Requirement: Advanced level kknowledge of Python is mandatory for attempting any goal in this milestone.
To contribute and publish select a pending milestone.
There are no completed milestones.
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Expert’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using SVM with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a SVM based model for prediction and tune it with GridSearchCV
- Derive the most optimal SVM model.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Expert’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using decision trees with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a decision trees based model for prediction and tune it with GridSearchCV
- Derive the most optimal decision trees model.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Expert’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using Naïve Bayes with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a Naïve Bayes based model for prediction and tune it with GridSearchCV
- Derive the most optimal Naïve Bayes model.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Expert’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using logistic regression with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a logistic regression based model for prediction and tune it with GridSearchCV
- Derive the most optimal logistic regression model.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Expert’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using random forest with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a random forest based model for prediction and tune it with GridSearchCV
- Derive the most optimal random forest model.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Expert’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using KNN with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a KNN based model for prediction and tune it with GridSearchCV
- Derive the most optimal KNN model.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1000 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Expert’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using LSTM with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a LSTM based model for prediction and tune it with GridSearchCV
- Derive the most optimal LSTM model.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1000 words
- Type unpaid
- Deadline 2 days later
- For all
- 1200 words
- unpaid
- 2 days later
- No files attached
Note: This is a part of ‘Expert’ level of expertise in Python programming. In order to work on this milestone, you need to perform all the steps related to data processing explained in the previous milestones:
- Milestone 1: Understanding the nature of banks’ financial transactions using Python
- Milestone 2: Using Python to classify financial transaction data according to amount
- Milestone 3: Generating new features in a financial transactions dataset using Python
- Milestone 4: Cleaning financial transactions dataset using Python
However, you do not need to write the articles.
Aim: Our dataset consists of over 10 lakh synthetic transactions of a bank. More information about the dataset can be found here. The ultimate goal of this module is to create a prediction model for detecting illegal transactions.
After cleaning and processing the data, prediction models can be generated to detect money laundering (illegal) transactions. The purpose of this milestone is to create the predictive model using CNN with accuracy of at least 85%.
Methodology: Use Jupyter Notebook (Python) to perform the following steps:
- Perform the data processing steps mentioned in Milestone 1.
- Perform the data processing steps mentioned in Milestone 2.
- Perform the data processing steps mentioned in Milestone 3.
- Perform the data processing steps mentioned in Milestone 4.
- Then, use the dataset created after Milestone 4. Balance and format the dataset by splitting the data with test split of 0.3, standardized, and generate tokenizers.
- Create a random CNN model for prediction and tune it with GridSearchCV
- Derive the most optimal CNN model.
- Evaluate the performance of model using performance metrics i.e. accuracy, F1-score, precision, recall, confusion matrix, and classification report.
Structure: after organising the data, write a 600 words article in the below format.
- Introduction to the problem of money laundering
- Major shortcomings of existing money laundering detection models
- Findings of the created prediction model (explain the findings of the performance metrics and compare it to the accuracy of previously developed models).
- References (of previous models which you are referring to).
Note:
Do not copy paste information from any source. It goes against our plagiarism rules.
Your submission must consist of the following:
- Article in MS Word format
- Jupyter notebook files (.ipynb)
- Size 1200 words
- Type unpaid
- Deadline 2 days later
- For all