524 skills found · Page 8 of 18
FePhyFoFum / QuartetsamplingQuartet Sampling method for phylogenetic branch support evaluation
viktor-platform / Cpt InterpreterThis sample app shows show how to interpret a CPT (.gef) to a soil layout using the Robertson method.
Thartvigsen / StopAndHopCode for Stop&Hop, a method for learning to classify irregularly-sampled time series early
Festusnkrumah / The SupremeFree Methods ✅💰, [7/27/21, 10:21 AM] Requirements ✓usa no. ✓vpn ie. Snapvpn.(that changes ip) ✓Gmail account Free Methods ✅💰, [7/27/21, 10:22 AM] STEPS Free Methods ✅💰, [7/27/21, 10:22 AM] ✓Firstly make sure you have a real USA number (it is only from someone from USA u can get that from) because u need an OTP to activate it from the person. After u have seen someone to give u a USA number. You signup with your Gmail account and password ✓After Signing up you input the Zip code of the number you want i.e States e.g California or Texas ✓After you input the Zip code,it shows you a list of USA number you can choose from according to your choice. ✓After selecting your number,it shows you a menu where you have to input (The real USA number to verify your Google voice number that will be given to you) ✓Make sure the person who gave you the number is online because you need an OTP from the person to verify it ✓Once you verify it,with the OTP congratulations .you now have a fully working USA number for all purpose ✓If you want to open any account like WhatsApp, Facebook, telegram and others,You can use the number to open it because you will be receiving your messages from the app Free Methods ✅💰, [7/28/21, 8:35 AM] [😱 Sticker] Free Methods ✅💰, [7/28/21, 8:36 AM] If you looking to open your own Anon bank drops for Dropping slips, Wire Transfers, Direct deposit, and (ACH) Bank Transfers, this is a guide you can follow: Free Methods ✅💰, [7/28/21, 8:37 AM] Next, Direct yourself to the Banking site of your choice. For this guide, I went with Capital One 360 Account. Once you're on the site and have opened the application for the 360 acct, start filling in the Fullz info Leave EVERYTHING EXACTLY THE SAME except the Email, which you should change to one that you have access to. Free Methods ✅💰, [7/28/21, 8:41 AM] Here's the correct fullz format that you'll need to use: - NAME: - ADDRESS: - CITY: - ZIP CODE: - STATE ISSUED: - D.O.B: - SSN: - MMN: - DRIVERSLICENSE: Some other details that may or may not be included are the IP ADDRESS,CC,CREDIT REPORT. Always do Background checks on your Fullz especially if you plan on using for opening A Bank Drop. Fullz also may come with CC but you can put it to the side if it was. Free Methods ✅💰, [7/28/21, 8:41 AM] Unless the Fullz you have is in your current state where you are then you may be able to slide your drop address to receive the card in there Some banks might ask if your mailing and home address are the same. Untick the box and enter you drop address there instead. I suggest opening a free outlook.com or yandex.com email in Fullz name once you've filled in everything. The application will process you to a questions screen on the Fullz which if you took it upon yourself to do before hand, a background check on the Fullz will greatly come in handy for this part of the process. If you answer the questions atleast good enough to fool the system, your drop application should go through and direct you to a screen with your acct and routing # or a screen asking you how you will fund the acct. Free Methods ✅💰, [7/28/21, 8:41 AM] Here's one thing to note on the Bank OpenUps and when applying for the Unemployment too: Always use a computer and proxy same as state. Banks can access your cookies and other stuff when you log on a device. A vpn ain’t always strong enough That’s why it’s better to use a computer. Free Methods ✅💰, [7/31/21, 1:45 PM] 👊How to Register Chime Bank and getting VCC for fast cashout. Free Methods ✅💰, [8/1/21, 10:11 AM] MOBILE DEPOSIT(MD) COMPLETE TUTORIAL✅ NOTE: Here are the things required for you to do a Mobile Deposit(MD) loading • A PC, Android or Iphone • A Paid Vpn • The Bank You Loading Mobile App • A Cheque Sample •The Drop details, including the online access. ALL TOOLS AVAILABLE @MoneyMachine1O1
etherceo1x1 / CodesBUILD YOUR OWN BLOCKCHAIN: A PYTHON TUTORIAL Download the full Jupyter/iPython notebook from Github here Build Your Own Blockchain – The Basics¶ This tutorial will walk you through the basics of how to build a blockchain from scratch. Focusing on the details of a concrete example will provide a deeper understanding of the strengths and limitations of blockchains. For a higher-level overview, I’d recommend this excellent article from BitsOnBlocks. Transactions, Validation, and updating system state¶ At its core, a blockchain is a distributed database with a set of rules for verifying new additions to the database. We’ll start off by tracking the accounts of two imaginary people: Alice and Bob, who will trade virtual money with each other. We’ll need to create a transaction pool of incoming transactions, validate those transactions, and make them into a block. We’ll be using a hash function to create a ‘fingerprint’ for each of our transactions- this hash function links each of our blocks to each other. To make this easier to use, we’ll define a helper function to wrap the python hash function that we’re using. In [1]: import hashlib, json, sys def hashMe(msg=""): # For convenience, this is a helper function that wraps our hashing algorithm if type(msg)!=str: msg = json.dumps(msg,sort_keys=True) # If we don't sort keys, we can't guarantee repeatability! if sys.version_info.major == 2: return unicode(hashlib.sha256(msg).hexdigest(),'utf-8') else: return hashlib.sha256(str(msg).encode('utf-8')).hexdigest() Next, we want to create a function to generate exchanges between Alice and Bob. We’ll indicate withdrawals with negative numbers, and deposits with positive numbers. We’ll construct our transactions to always be between the two users of our system, and make sure that the deposit is the same magnitude as the withdrawal- i.e. that we’re neither creating nor destroying money. In [2]: import random random.seed(0) def makeTransaction(maxValue=3): # This will create valid transactions in the range of (1,maxValue) sign = int(random.getrandbits(1))*2 - 1 # This will randomly choose -1 or 1 amount = random.randint(1,maxValue) alicePays = sign * amount bobPays = -1 * alicePays # By construction, this will always return transactions that respect the conservation of tokens. # However, note that we have not done anything to check whether these overdraft an account return {u'Alice':alicePays,u'Bob':bobPays} Now let’s create a large set of transactions, then chunk them into blocks. In [3]: txnBuffer = [makeTransaction() for i in range(30)] Next step: making our very own blocks! We’ll take the first k transactions from the transaction buffer, and turn them into a block. Before we do that, we need to define a method for checking the valididty of the transactions we’ve pulled into the block. For bitcoin, the validation function checks that the input values are valid unspent transaction outputs (UTXOs), that the outputs of the transaction are no greater than the input, and that the keys used for the signatures are valid. In Ethereum, the validation function checks that the smart contracts were faithfully executed and respect gas limits. No worries, though- we don’t have to build a system that complicated. We’ll define our own, very simple set of rules which make sense for a basic token system: The sum of deposits and withdrawals must be 0 (tokens are neither created nor destroyed) A user’s account must have sufficient funds to cover any withdrawals If either of these conditions are violated, we’ll reject the transaction. In [4]: def updateState(txn, state): # Inputs: txn, state: dictionaries keyed with account names, holding numeric values for transfer amount (txn) or account balance (state) # Returns: Updated state, with additional users added to state if necessary # NOTE: This does not not validate the transaction- just updates the state! # If the transaction is valid, then update the state state = state.copy() # As dictionaries are mutable, let's avoid any confusion by creating a working copy of the data. for key in txn: if key in state.keys(): state[key] += txn[key] else: state[key] = txn[key] return state In [5]: def isValidTxn(txn,state): # Assume that the transaction is a dictionary keyed by account names # Check that the sum of the deposits and withdrawals is 0 if sum(txn.values()) is not 0: return False # Check that the transaction does not cause an overdraft for key in txn.keys(): if key in state.keys(): acctBalance = state[key] else: acctBalance = 0 if (acctBalance + txn[key]) < 0: return False return True Here are a set of sample transactions, some of which are fraudulent- but we can now check their validity! In [6]: state = {u'Alice':5,u'Bob':5} print(isValidTxn({u'Alice': -3, u'Bob': 3},state)) # Basic transaction- this works great! print(isValidTxn({u'Alice': -4, u'Bob': 3},state)) # But we can't create or destroy tokens! print(isValidTxn({u'Alice': -6, u'Bob': 6},state)) # We also can't overdraft our account. print(isValidTxn({u'Alice': -4, u'Bob': 2,'Lisa':2},state)) # Creating new users is valid print(isValidTxn({u'Alice': -4, u'Bob': 3,'Lisa':2},state)) # But the same rules still apply! True False False True False Each block contains a batch of transactions, a reference to the hash of the previous block (if block number is greater than 1), and a hash of its contents and the header Building the Blockchain: From Transactions to Blocks¶ We’re ready to start making our blockchain! Right now, there’s nothing on the blockchain, but we can get things started by defining the ‘genesis block’ (the first block in the system). Because the genesis block isn’t linked to any prior block, it gets treated a bit differently, and we can arbitrarily set the system state. In our case, we’ll create accounts for our two users (Alice and Bob) and give them 50 coins each. In [7]: state = {u'Alice':50, u'Bob':50} # Define the initial state genesisBlockTxns = [state] genesisBlockContents = {u'blockNumber':0,u'parentHash':None,u'txnCount':1,u'txns':genesisBlockTxns} genesisHash = hashMe( genesisBlockContents ) genesisBlock = {u'hash':genesisHash,u'contents':genesisBlockContents} genesisBlockStr = json.dumps(genesisBlock, sort_keys=True) Great! This becomes the first element from which everything else will be linked. In [8]: chain = [genesisBlock] For each block, we want to collect a set of transactions, create a header, hash it, and add it to the chain In [9]: def makeBlock(txns,chain): parentBlock = chain[-1] parentHash = parentBlock[u'hash'] blockNumber = parentBlock[u'contents'][u'blockNumber'] + 1 txnCount = len(txns) blockContents = {u'blockNumber':blockNumber,u'parentHash':parentHash, u'txnCount':len(txns),'txns':txns} blockHash = hashMe( blockContents ) block = {u'hash':blockHash,u'contents':blockContents} return block Let’s use this to process our transaction buffer into a set of blocks: In [10]: blockSizeLimit = 5 # Arbitrary number of transactions per block- # this is chosen by the block miner, and can vary between blocks! while len(txnBuffer) > 0: bufferStartSize = len(txnBuffer) ## Gather a set of valid transactions for inclusion txnList = [] while (len(txnBuffer) > 0) & (len(txnList) < blockSizeLimit): newTxn = txnBuffer.pop() validTxn = isValidTxn(newTxn,state) # This will return False if txn is invalid if validTxn: # If we got a valid state, not 'False' txnList.append(newTxn) state = updateState(newTxn,state) else: print("ignored transaction") sys.stdout.flush() continue # This was an invalid transaction; ignore it and move on ## Make a block myBlock = makeBlock(txnList,chain) chain.append(myBlock) In [11]: chain[0] Out[11]: {'contents': {'blockNumber': 0, 'parentHash': None, 'txnCount': 1, 'txns': [{'Alice': 50, 'Bob': 50}]}, 'hash': '7c88a4312054f89a2b73b04989cd9b9e1ae437e1048f89fbb4e18a08479de507'} In [12]: chain[1] Out[12]: {'contents': {'blockNumber': 1, 'parentHash': '7c88a4312054f89a2b73b04989cd9b9e1ae437e1048f89fbb4e18a08479de507', 'txnCount': 5, 'txns': [{'Alice': 3, 'Bob': -3}, {'Alice': -1, 'Bob': 1}, {'Alice': 3, 'Bob': -3}, {'Alice': -2, 'Bob': 2}, {'Alice': 3, 'Bob': -3}]}, 'hash': '7a91fc8206c5351293fd11200b33b7192e87fad6545504068a51aba868bc6f72'} As expected, the genesis block includes an invalid transaction which initiates account balances (creating tokens out of thin air). The hash of the parent block is referenced in the child block, which contains a set of new transactions which affect system state. We can now see the state of the system, updated to include the transactions: In [13]: state Out[13]: {'Alice': 72, 'Bob': 28} Checking Chain Validity¶ Now that we know how to create new blocks and link them together into a chain, let’s define functions to check that new blocks are valid- and that the whole chain is valid. On a blockchain network, this becomes important in two ways: When we initially set up our node, we will download the full blockchain history. After downloading the chain, we would need to run through the blockchain to compute the state of the system. To protect against somebody inserting invalid transactions in the initial chain, we need to check the validity of the entire chain in this initial download. Once our node is synced with the network (has an up-to-date copy of the blockchain and a representation of system state) it will need to check the validity of new blocks that are broadcast to the network. We will need three functions to facilitate in this: checkBlockHash: A simple helper function that makes sure that the block contents match the hash checkBlockValidity: Checks the validity of a block, given its parent and the current system state. We want this to return the updated state if the block is valid, and raise an error otherwise. checkChain: Check the validity of the entire chain, and compute the system state beginning at the genesis block. This will return the system state if the chain is valid, and raise an error otherwise. In [14]: def checkBlockHash(block): # Raise an exception if the hash does not match the block contents expectedHash = hashMe( block['contents'] ) if block['hash']!=expectedHash: raise Exception('Hash does not match contents of block %s'% block['contents']['blockNumber']) return In [15]: def checkBlockValidity(block,parent,state): # We want to check the following conditions: # - Each of the transactions are valid updates to the system state # - Block hash is valid for the block contents # - Block number increments the parent block number by 1 # - Accurately references the parent block's hash parentNumber = parent['contents']['blockNumber'] parentHash = parent['hash'] blockNumber = block['contents']['blockNumber'] # Check transaction validity; throw an error if an invalid transaction was found. for txn in block['contents']['txns']: if isValidTxn(txn,state): state = updateState(txn,state) else: raise Exception('Invalid transaction in block %s: %s'%(blockNumber,txn)) checkBlockHash(block) # Check hash integrity; raises error if inaccurate if blockNumber!=(parentNumber+1): raise Exception('Hash does not match contents of block %s'%blockNumber) if block['contents']['parentHash'] != parentHash: raise Exception('Parent hash not accurate at block %s'%blockNumber) return state In [16]: def checkChain(chain): # Work through the chain from the genesis block (which gets special treatment), # checking that all transactions are internally valid, # that the transactions do not cause an overdraft, # and that the blocks are linked by their hashes. # This returns the state as a dictionary of accounts and balances, # or returns False if an error was detected ## Data input processing: Make sure that our chain is a list of dicts if type(chain)==str: try: chain = json.loads(chain) assert( type(chain)==list) except: # This is a catch-all, admittedly crude return False elif type(chain)!=list: return False state = {} ## Prime the pump by checking the genesis block # We want to check the following conditions: # - Each of the transactions are valid updates to the system state # - Block hash is valid for the block contents for txn in chain[0]['contents']['txns']: state = updateState(txn,state) checkBlockHash(chain[0]) parent = chain[0] ## Checking subsequent blocks: These additionally need to check # - the reference to the parent block's hash # - the validity of the block number for block in chain[1:]: state = checkBlockValidity(block,parent,state) parent = block return state We can now check the validity of the state: In [17]: checkChain(chain) Out[17]: {'Alice': 72, 'Bob': 28} And even if we are loading the chain from a text file, e.g. from backup or loading it for the first time, we can check the integrity of the chain and create the current state: In [18]: chainAsText = json.dumps(chain,sort_keys=True) checkChain(chainAsText) Out[18]: {'Alice': 72, 'Bob': 28} Putting it together: The final Blockchain Architecture¶ In an actual blockchain network, new nodes would download a copy of the blockchain and verify it (as we just did above), then announce their presence on the peer-to-peer network and start listening for transactions. Bundling transactions into a block, they then pass their proposed block on to other nodes. We’ve seen how to verify a copy of the blockchain, and how to bundle transactions into a block. If we recieve a block from somewhere else, verifying it and adding it to our blockchain is easy. Let’s say that the following code runs on Node A, which mines the block: In [19]: import copy nodeBchain = copy.copy(chain) nodeBtxns = [makeTransaction() for i in range(5)] newBlock = makeBlock(nodeBtxns,nodeBchain) Now assume that the newBlock is transmitted to our node, and we want to check it and update our state if it is a valid block: In [20]: print("Blockchain on Node A is currently %s blocks long"%len(chain)) try: print("New Block Received; checking validity...") state = checkBlockValidity(newBlock,chain[-1],state) # Update the state- this will throw an error if the block is invalid! chain.append(newBlock) except: print("Invalid block; ignoring and waiting for the next block...") print("Blockchain on Node A is now %s blocks long"%len(chain)) Blockchain on Node A is currently 7 blocks long New Block Received; checking validity... Blockchain on Node A is now 8 blocks long
uraimo / SwizzlingInSwiftSwift Method Swizzling Sample
StanJulia / StanSample.jlWIP: Wrapper package for the sample method in Stan's cmdstan executable.
MichelLutz1994 / Conformal PredictionThis projects contains different conformal methods and approaches. Includes code generated for a experimental evaluation of a multidimensional, low-sample size biomedical dataset of oncological subjects.
Jiang-HB / CEMNetSampling Network Guided Cross-Entropy Method for Unsupervised Point Cloud Registration (Accepted by ICCV-2021)
shihai1991 / Kernel Density PeaksWe develop the clustering approach by fast-search-and-find of density peaks which use the kernel function for mapping the input sample objects to the high dimensional feature space and amplifying the original sample objects’ characteristics, thereby researching the local density of the object attribute based on similarity measure. In order to identify our method’s effectiveness, we compare our method to other popular clustering algorithms. From the result analysis, we could conclude that our method have a better result.
gamaleldin / TMEThis code package is for the Tensor-Maximum-Entropy (TME) method. This method generates random surrogate data that preserves a specified set of first and second order marginal moments of a data tensor, which makes it well equipped to test for the null hypothesis that a structure in data is an epiphenomenon of these specified set of primary features of the data tensor. The random surrogate data are sampled from a maximum entropy distribution. This distribution unlike traditional maximum entropy method have constraints on the marginal first and second moments of the tensor mode.
JJRyan0 / Outlier Detection Algorithm Isolation ForestsBNP Paribas Kaggle Data Set Data source: https://www.kaggle.com/c/bnp-paribas-cardif-claims-management Outlier Detection- Ensemble unsupervised learning method - Isolation Forest The isolation algorithm is an unsupervised machine learning method used to detect abnormal anomalies in data such as outliers. This is once again a randomized & recursive partition of the training data in a tree structure. The number of sub samples and tree size is specified and tuned appropriately. The distance to the outlier is averaged calculating an anomaly detection score: 1 = outlier 0 = close to zero are normal data.
ekhiru / Top K MallowsMallows Kendall. A python package to for Mallows Model with top-k and complete rankings using Kendall's-tau distance. By Ahmed Boujaada, Fabien Collas and Ekhine Irurozki. We present methods for inference in the Mallows Model (MM), the best-known distribution for permutations. This is short tutorial for top-k rankings and complete rankings under the Kendall's-tau distance. Theoretical details are given in Fabien Collas and Ekhine Irurozki (2020). Concentric mixtures of Mallows Models for top-k rankings: sampling and identifiability. In: International Conference on Machine Learning (ICML 21). 2021.
supercodestart / Convert Color🌈When it comes to converting colors based on the difference between two sample colors, there are a few approaches you can take. One common method is to calculate the color difference using various color models like RGB, or HSL. Once you have the color difference value, you can then apply it to your target color to achieve the desired result.
HuHaigen / COVID 19 Lung Infection SegmentationDue to the irregular shapes,various sizes and indistinguishable boundaries between the normal and infected tissues, it is still a challenging task to accurately segment the infected lesions of COVID-19 on CT images. In this paper, a novel segmentation scheme is proposed for the infections of COVID-19 by enhancing supervised information and fusing multi-scale feature maps of different levels based on the encoder-decoder architecture. To this end, a deep collaborative supervision (Co-supervision) scheme is proposed to guide the network learning the features of edges and semantics. More specifically, an Edge Supervised Module (ESM) is firstly designed to highlight low-level boundary features by incorporating the edge supervised information into the initial stage of down-sampling. Meanwhile, an Auxiliary Semantic Supervised Module (ASSM) is proposed to strengthen high-level semantic information by integrating mask supervised information into the later stage. Then an Attention Fusion Module (AFM) is developed to fuse multiple scale feature maps of different levels by using an attention mechanism to reduce the semantic gaps between high-level and low-level feature maps. Finally, the effectiveness of the proposed scheme is demonstrated on four various COVID-19 CT datasets. The results show that the proposed three modules are all promising. Based on the baseline (ResUnet), using ESM, ASSM, or AFM alone can respectively increase Dice metric by 1.12%, 1.95%,1.63% in our dataset, while the integration by incorporating three models together can rise 3.97%. Compared with the existing approaches in various datasets, the proposed method can obtain better segmentation performance in some main metrics, and can achieve the best generalization and comprehensive performance.
lxcnju / SamplingSome methods to sampling data points from a given distribution.
cakebake / Yii2 ActionlogAutomatically logs user actions like create, update, delete. In addition, you can manually apply the method "ActionLog::add('Save sample message')", where you will need.
ruvnet / Onnx AgentA complete set of requirements—covering UX, CLI, and code—that builds on the previous pipeline for training and optimizing ONNX models with test‑time compute methods using DSPy. This document specifies user stories, command‐line interface arguments, and sample code snippets to guide implementation.
Archeries / StrideLengthEstimationThe lack of benchmarking datasets for pedestrian stride length estimation makes it hard to pinpoint differences of published methods. Existing datasets either lack the ground-truth of each stride or are limited to small spaces with single scene or motion pattern. To fully evaluate the performance of proposed ASLE algorithm, we conducted benchmark dataset for natural pedestrian dead reckoning using smartphone sensors and FM-INS module. we leveraged the FM-INS module to provide the ground-truth of each stride with motion distance errors in 0.3% of the entire travel distance. The datasets were obtained from a group of healthy adults with natural motion patterns (fast walking, normal walking, slow walking, running, jumping). The datasets contained more than 22 km, 10000 strides of gait measurements. The datasets cover both indoor and outdoor cases, including: stairs, escalators, elevators, office environments, shopping mall, streets and metro station. To make it easier for readers to replicate experiment, we shared the sampling software.
theophilegervet / Discrete Off Policy EvaluationImplementation of importance sampling, direct, and hybrid methods for off-policy evaluation.
