Connect with us
https://ainews.site/wp-content/uploads/2021/11/zox-leader.png

Published

on

The Ultimate Managed Hosting Platform

Un gruppo di senatori democratici ha chiesto alla tassa federale sul commercio di analizzare se la società di verifica dell’identificazione ID.me abbia ingannato o meno illegalmente clienti e società di autorità sull’uso del controverso programma software di riconoscimento facciale.

ID.me, che utilizza una combinazione di selfie, scansioni di documenti e diverse strategie per confermare che l’identità delle persone online è cresciuta rapidamente durante la pandemia di coronavirus, in gran parte a causa dei contratti con i dipartimenti statali per la disoccupazione e le società federali insieme a Inside Income Servizio.

Il che afferma di avere più di 80 milioni di clienti, ha inoltre affrontato domande crescenti su tale posizione oltre al fatto che un appaltatore personale debba o meno essere autorizzato a comportarsi come un guardiano di fatto per . E’ già oggetto di un’indagine del Comitato per il controllo interno e le riforme.

La chiave dei problemi sono state le domande sull’uso di ID.me . Dopo aver affermato a lungo di aver utilizzato esclusivamente competenze “one-to-one” che, a differenza dei selfie scattati dai clienti alle scansioni di una patente di guida o di un diverso documento d’identità rilasciato dal governo, la società all’inizio di questi 12 mesi ha dichiarato di mantenere veramente un database di scansioni facciali e ha utilizzato competenze “uno-a-molti” extra controverse.

In una lettera inviata al presidente della FTC Lina Khan chiedendo un’indagine, mercoledì i senatori Ron Wyden, Cory Booker, Ed Markey e Alex Padilla hanno chiesto all’autorità di regolamentazione di esaminare se le dichiarazioni della società indicassero o meno il suo uso di “imprese ingannevoli e sleali” illegali pratiche”.

Le dichiarazioni preliminari di ID.me sul suo programma software di riconoscimento facciale sembravano essere state utilizzate per fuorviare ogni cliente e scrivono i senatori nella lettera.

“Gli individui hanno un motivo esplicito per essere coinvolti nella distinzione tra queste due varietà di riconoscimento facciale”, hanno affermato i senatori. “Mentre il riconoscimento uno a uno include una comparabilità una tantum di due immagini al fine di affermare l’identificazione di un richiedente, l’utilizzo del riconoscimento uno a molti significa che decine di milioni di individui innocui possono vedersi interrogare all’infinito le loro immagini come parte di una “fila” digitale.

L’utilizzo di competenze uno-a-molti ha inoltre sollevato problemi sulle false corrispondenze che hanno portato i candidati a vedersi negati i vantaggi oa dover attendere mesi per ottenerli, hanno affermato i senatori. La possibilità era “particolarmente acuta” per le persone in ombra, con gli esami che mostravano che molti algoritmi di riconoscimento facciale hanno aumentato le accuse di false corrispondenze per i clienti neri e asiatici.

Domande sull’uso di ID.me è emerso a gennaio dopo la pubblicazione di un articolo di Bloomberg Businessweek sulla società. Ciò ha coinciso con problemi crescenti su un contratto da 86 milioni di dollari con l’IRS che avrebbe potuto richiedere ai contribuenti americani di iscriversi a ID.me al fine di utilizzare i fornitori in linea. Da allora l’IRS ha introdotto le opzioni per ID.me.

Nelle interviste con Bloomberg Businessweek, oltre che in un blog di gennaio pubblicato da Bake Corridor, il suo , ID.me aveva difeso l’equità dei suoi programmi di riconoscimento facciale in parte dicendo che l’azienda si limitava a utilizzare un sistema di corrispondenza uno a uno che confronta un selfie scattato dalla persona con la sua foto ID. “La nostra partita 1:1 corrisponde a scattare un selfie per sbloccare uno smartphone. ID.me non usa il riconoscimento facciale 1:molti, che è molto avanzato e problematico”, ha scritto Corridor all’interno della pubblicazione.

Una settimana dopo, Corridor ha corretto il file in una pubblicazione su LinkedIn, affermando che l’azienda utilizzava un sistema di riconoscimento facciale uno-a-molti, in cui un’immagine è in contrasto con database di fotografie spesso enormi.

Corridor, in quella frase, affermava che l’uso da parte dell’azienda di un algoritmo uno-a-molti era limitato ai controlli per le applicazioni della presidenza che si dice siano incentrate sulla criminalità organizzata e non contenga alcun database esterno o delle autorità.

“Questo passaggio non è legato alla verifica dell’identificazione”, ha scritto Corridor. “Non impedisce ai clienti autentici di verificare la propria identificazione, né viene utilizzato per ogni altro obiettivo oltre a prevenire il furto di identificazione. La conoscenza rivela che l’eliminazione di questa gestione comporterebbe immediatamente un importante furto di identificazione e criminalità organizzata”.

Mentre ricercatori e attivisti hanno sollevato questioni sulla privacy, sull’accuratezza e sui punti di pregiudizio in ciascun programma, numerose ricerche presentano i programmi uno-a-molti che funzionano male sulle fotografie di individui con i pori e la pelle più scuri, in particolare le donne. Le società corrispondenti ad Amazon.com Inc. e Microsoft Corp. hanno di conseguenza sospeso la promozione di questi tipi di software ai dipartimenti di polizia e hanno chiesto la regolamentazione della presidenza all’interno della disciplina.

Sulla base dei messaggi interni di Slack ottenuti da CyberScoop, il programma software di ID.me, dimostrato all’IRS, ha utilizzato il prodotto Rekognition di Amazon, lo stesso identico che Amazon ha smesso di promuovere per l’applicazione della normativa.

La società non aveva rivelato il suo uso di Recognition in un white paper sulla sua esperienza pubblicato all’inizio di quel mese.

I sostenitori della privacy e della sicurezza dell’intelligence sintetica si sono inoltre lamentati del fatto che ID.me non ha aperto i suoi programmi di riconoscimento facciale all’audit esterno.


I pannelli interni sondano il governo sull’uso del software di riconoscimento facciale


©2022 Bloomberg LP
Distribuito da Tribune Content material Company, LLC.

Quotazione:
I senatori cercano l’indagine FTC sull’esperienza dei selfie del fornitore IRS ID.me (2022, 18 maggio)
recuperato il 18 maggio 2022
da https://techxplore.com/information/2022-05-senators-ftc-probe-irs-idme.html

Questo documento è soggetto a copyright. A parte ogni onesto trattamento a fini di esame o analisi personale, n
la metà potrebbe anche essere riprodotta senza il permesso scritto. Il materiale di contenuto viene offerto esclusivamente per funzioni informative.



The Ultimate Managed Hosting Platform

Source link

Continue Reading

Ultime notizie

Piuttosto che concentrarci sui diritti speculativi dell’IA senziente, dobbiamo affrontare i diritti umani – L’ultima novità nell’intelligenza artificiale | Robotica AI

Published

on

Rather than focus on the speculative rights of sentient AI, we need to address human rights

The Ultimate Managed Hosting Platform

Le persone di solito non sono i giudici più efficaci della coscienza a causa della loro tendenza ad assegnare tratti umani a entità non umane. Punteggio di credito: Shutterstock

Una raffica di esercizi si è verificata sui social media dopo che Blake Lemoine, uno sviluppatore di Google, è stato messo in partenza per aver affermato che LaMDA, un chatbot, si era trasformato in senziente, in diverse espressioni, aveva acquisito il potere di provare le emozioni. In aiuto della sua dichiarazione, Lemoine estratti pubblicati da uno scambio con LaMDA, che ha risposto alle domande dicendo: “consapevole della mia esistenza, desidero saperne di più sul mondo e a volte mi sento felice o triste”. Ha anche affermato di avere gli stessi “desideri e bisogni delle persone”.

Sembrerebbe un mestiere banale e non vale la pena dichiararlo senziente, anche quando lo è sembra più pratico di primi tentativi. Anche la prova del mestiere di Lemoine lo era modificato da diverse sessioni di chat. Tuttavia, la natura dinamica e fluida del dialogo è spettacolare.

Prima di iniziare a fare una fattura dei diritti per vogliamo considerare come le esperienze e i pregiudizi umani possono avere un effetto sulla nostra convinzione nel sintetico (AI).

Produrre il fittizio

In l’IA è cambiata in a termine universale, spesso usato senza troppe riflessioni. L’artificialità sottolinea la natura non biologica di tali metodi e la natura sommaria del codice, oltre ai percorsi di studio non umani, e condotta.

Specializzandosi nell’artificialità, le semplici informazioni che le IA sono create dalle persone e fanno o aiutano nella selezione delle persone possono essere ignorate. I risultati di tali selezioni possono avere un’impressione consequenziale su persone equivalenti giudicare la solvibilità, trovare e selezionare compagni o anche determinando una potenziale criminalità.

I chatbot, quelli buoni, sono progettati per simulare le interazioni sociali delle persone. I chatbot sono diventati una caratteristica fin troppo familiare dell’assistenza clienti online. Se un acquirente desidera solo una risposta prevedibile, apparentemente non saprebbe di aver interagito con un’IA.

Caratteristiche della complessità

La distinzione tra chatbot di facile servizio clienti e varietà extra sottili come LaMDA è un’operazione di complessità in ogni set di dati utilizzato per istruire l’IA e le basi che governano il commercio.

L’intelligenza mostra diverse capacità-ci sono forme di intelligenza dominio-specifiche e dominio-generale. L’intelligence specifica dell’area contiene compiti come usare biciclette, eseguire procedure chirurgiche, nominare uccelli o prendere parte agli scacchi. L’intelligenza generale dell’area contiene abilità normali come creatività, ragionamento e risoluzione dei problemi.

I programmatori hanno fatto una buona strada nella progettazione di IA che possono mostrare intelligenza specifica del dominio nelle azioni a partire da condurre ricerche online e giocare a scacchi, riconoscere oggetti e diagnosticare condizioni mediche: se decideremo i fondamenti che governano la considerazione umana, educheremo poi all’IA queste linee guida.

L’intelligenza comune, ciò che molti considerano essenzialmente umana, è una scuola molto più difficile. Nelle persone, è apparentemente dipendente dal convergenza dei diversi tipi di conoscenze e competenze. Capacità come la lingua presentare strumenti particolarmente utili, dando alle persone il potere di raccogliere e mescolare i dati in tutti i domini.

Così, mentre i costruttori lo sono stati regolarmente fiduciosi sulle prospettive dell’intelligenza artificiale generale simile a quella umana, queste speranze non sono state ancora realizzate.

Pensa all’IA

Afferma che un’IA è forse una sfida attuale senziente oltre quella dell’intelligenza normale. I filosofi hanno a lungo identificato che ora abbiamo problemi a capire gli altri stati mentaliper non parlare della comprensione in cosa costituisce la coscienza animali non umani.

Per conoscere le affermazioni della senzienza, dobbiamo ora guardare a come le persone decidono gli altri. Noi regolarmente attribuire erroneamente azioni ad altriin genere assumendolo condividono i nostri valori e preferenze. Gli psicologi hanno notato che i bambini dovrebbero studiare per quanto riguarda il degli altri e che avere più modelli o essere incorporati in ulteriori culture collettivistiche possono aumentare il loro potenziale per afferrare gli altri.

Quando si giudica l’intelligenza di un’IA, sembra che le persone si antropomorfichino più di quanto le IA siano in realtà senzienti. Molto di questo ha a che fare con familiarità— accrescendo la nostra pubblicità a cose o individui, possiamo aumentare la nostra preferenza per loro.

Le affermazioni di sensibilità fatte da questi come Lemoine devono essere interpretate su questo mite.

Possiamo credere all’IA?

Il Prova di Turing può essere utilizzato per scoprire se una macchina può supporre in modo indistinguibile da un individuo. Mentre le risposte di LaMDA sono decisamente simili a quelle umane, ciò significa che è più efficace nello studio dei modelli. La sensibilità non è richiesta.

Solo perché qualcuno si fida di un chatbot non implica che la convinzione sia giustificata. Piuttosto che specializzarci nella natura estremamente speculativa dell’intelligenza artificiale, dovremmo, in alternativa, concentrare i nostri sforzi per prenderci cura dei punti sociali e morali che hanno un effetto sulle persone.

Affrontiamo divario digitale tra abbienti e non abbienti e squilibri di potere e di distribuzione nella creazione di questi sistemi.

I programmi devono essere chiari e spiegabili per consentire ai clienti di determinare. Spiegabilità richiede che le persone, i governi e il settore non pubblico lavorino collettivamente per afferrare e regolare l’intelligenza sintetica e la sua utilità.

Dovremmo anche esserne consapevoli la nostra tendenza umana ad antropomorfizzare può essere semplice sfruttato dai designer. In alternativa, lo faremmo rifiuta i prodotti utili dell’IA che non si incrociano come umani. Nella nostra epoca di intrecciodobbiamo essere importanti in chi e in cosa crediamo.


Dovremmo preoccuparci del fatto che l’IA di Google sia senziente?


Offerto da
La conversazione


Questo testo è stato ripubblicato da La conversazione sotto una licenza Inventive Commons. Impara il articolo originale.

Quotazione:
Piuttosto che occuparci dei diritti speculativi dell’IA senziente, dobbiamo affrontare i diritti umani (2022, 30 giugno)
recuperato il 1 luglio 2022
da https://techxplore.com/information/2022-06-focus-speculative-rights-sentient-ai.html

Questo documento è soggetto a copyright. Al di là di ogni veridicità di trattative finalizzate alla ricerca o all’analisi personale, n
la metà potrebbe anche essere riprodotta senza il permesso scritto. Il materiale contenuto viene fornito esclusivamente per le funzioni di dati.



The Ultimate Managed Hosting Platform

Source link

Continue Reading

Ultime notizie

Un modello che consente ai robot di seguire e guidare gli esseri umani in ambienti affollati – L’ultima novità nell’intelligenza artificiale | Robotica AI

Published

on

A model that allows robots to follow and guide humans in crowded environments

The Ultimate Managed Hosting Platform

Stack è una sorta di lineare struttura dati che consente l’archiviazione e l’ingresso di conoscenze rispettose dell’ambiente. Poiché il significato letterale di stack significa, questa costruzione della conoscenza si basa sulla logica di memorizzare i componenti uno sopra l’altro. Ci sono molti esempi del mondo reale della pila della nostra vita quotidiana, corrispondenti a una pila di piatti, una pila di appunti, una pila di indumenti e molti altri. Come ogni altro linguaggio di programmazione rispettoso dell’ambiente, Python consente inoltre un’implementazione pulita dello stack e numerose diverse costruzioni di conoscenza. Immediatamente, in questo articolo, studieremo lo stack Python e come implementarlo.

Cos’è Stack in Python?

Stack è una costruzione di conoscenza lineare che funziona secondo il precetto di “Final In First Out (LIFO). Ciò significa che il componente che entra per primo nello stack esce finale. Il periodo di tempo che utilizziamo per inviare il meteo a uno stack è chiamato “Push”, mentre il periodo di tempo per eliminare il meteo da uno stack è chiamato “Pop”. Pertanto, diremo che poiché uno stack ha solo un traguardo aperto, push e popping non possono avvenire contemporaneamente. Di seguito è stata mostrata un’illustrazione grafica dell’operazione PUSH e POP all’interno dello stack:

Illustrazione pittorica di stack, push e pop

Il tipo di dati integrato di Python che utilizziamo per implementare Python è la checklist di Python. Inoltre, per esercitare operazioni PUSH e POP su uno stack, utilizziamo append() e pop() perform della checklist Python.

Get your arms on the Python Stack course and study extra about it.

Strategie di Stack

Probabilmente le strategie più fondamentali relative a uno Stack in Python sono le seguenti:

  • spingere(n)– Questa può essere una metodologia di stack definita dall’utente utilizzata per inserire un componente nello stack. Il componente da spingere viene consegnato nella sua argomentazione.
  • pop()– Vogliamo che questa metodologia tolga il componente più in alto dallo stack.
  • è vuoto()– Vogliamo che questa metodologia verifichi se lo stack è vuoto o meno.
  • dimensione()– Vogliamo che questa metodologia ottenga la scala dello stack.
  • primo ()– Questa metodologia di impilamento può essere utilizzata per restituire il riferimento al componente più in alto o all’ultimo componente inserito in uno stack.

Funzionalità relative a Python Stack

Ci sono un sacco di funzioni utili in Python che ci aiutano a prenderci cura di uno stack in modo efficace. Diamo una breve occhiata a queste caratteristiche –

  • len()– Questa metodologia dello stack viene utilizzata per restituire la scala dello stack. Questa esecuzione può essere utilizzata all’interno della definizione della metodologia isempty() in uno stack Python.
  • append(n)– Questa esecuzione Python viene utilizzata per inserire un componente nello stack. Il componente da spingere viene consegnato nella sua argomentazione.
  • pop()– Questa metodologia, correlata agli elenchi Python, viene utilizzata per eliminare il componente più in alto dallo stack.

Implementazione di Stack

Esistono 4 metodi con cui eseguiremo l’implementazione di uno stack in Python-

  • lista di controllo
  • collezioni.deque
  • coda.LifoQueue
  • Lista di controllo a collegamento singolo

Di questi tre, l’approccio più semplice e preferito per implementare uno stack in Python è la checklist. Vediamo l’implementazione di uno stack in Python utilizzando le liste.

Implementazione utilizzando il record

# Stack Creation
def create_stack():
    stack = checklist()            #declaring an empty checklist
    return stack


# Checking for empty stack
def Isempty(stack):
    return len(stack) == 0


# Inserting gadgets into the stack
def push(stack, n):
    stack.append(n)
    print("pushed merchandise: " + n)


# Elimination of a component from the stack
def pop(stack):
    if (Isempty(stack)):
        return "stack is empty"
    else:
        return stack.pop()

# Displaying the stack components
def present(stack):
    print("The stack components are:")
    for i in stack:
        print(i)
        
stack = create_stack()
push(stack, str(10))
push(stack, str(20))
push(stack, str(30))
push(stack, str(40))
print("popped merchandise: " + pop(stack))
present(stack)

Produzione:

Tuttavia, il soggetto del ritmo si trasforma in una limitazione significativa proprio qui quando si affronta uno stack in aumento. I gadget in un elenco vengono salvati uno dopo l’opposto contenuto nella reminiscenza. Pertanto, se lo stack cresce più del blocco di reminiscenza assegnato alla checklist, Python deve eseguire alcune nuove allocazioni di reminiscenza, portando ad alcuni append() che impiegano molto più tempo del resto durante la chiamata.

Implementazione utilizzando collections.deque

Useremo inoltre la classe deque del modulo delle raccolte Python per implementare uno stack. Poiché una coda deque o double-ended ci consente di inserire ed eliminare componenti da ogni ingresso e lato posteriore, è forse più appropriato a volte quando richiediamo prima operazioni append() e pop().

from collections import deque  

def create_stack():  
    stack = deque()    #Creating empty deque
    return stack 
  
# PUSH operation utilizing append()
def push(stack, merchandise):
    stack.append(merchandise)

  
#POP operation
def pop(stack):
    if(stack):
        print('Component popped from stack:')
        print(stack.pop())
    else:
        print('Stack is empty')
    

#Displaying Stack
def present(stack):
    print('Stack components are:')
    print(stack)
    
new_stack=create_stack()
push(new_stack,25)
push(new_stack,56)
push(new_stack,32)
present(new_stack)

pop(new_stack)
present(new_stack)

Produzione:

Implementazione utilizzando queue.LifoQueue

Il modulo coda di Python è costituito da una coda LIFO. Una coda LIFO non è altro che uno stack. Pertanto, implementeremo semplicemente e con successo uno stack in Python utilizzando il modulo coda. Per un LifoQueue, abbiamo alcune funzionalità che possono essere utili nell’implementazione dello stack, corrispondenti a qsize(), full(), empty(), put(n), get() come visto nel seguente pezzo di codice. Il parametro della dimensione massima di LifoQueue definisce il limite delle cose che lo stack può mantenere.

from queue import LifoQueue
  
# Initializing a stack
def new():
    stack = LifoQueue(maxsize=3)   #Fixing the stack dimension
    return stack

#PUSH utilizing put(n) 
def push(stack, merchandise):
    if(stack.full()):                      #Checking if the stack is full
        print("The stack is already full")
    else:
        stack.put(merchandise)
        print("Dimension: ", stack.qsize())     #Figuring out the stack dimension

#POP utilizing get()
def pop(stack):
    if(stack.empty()):              #Checking if the stack is empty
        print("Stack is empty")
    else:
        print('Component popped from the stack is ', stack.get())         #Eradicating the final component from stack
        print("Dimension: ", stack.qsize())

stack=new()
pop(stack)
push(stack,32)
push(stack,56)
push(stack,27)
pop(stack)

Produzione:

Implementazione utilizzando una checklist collegata singolarmente

Gli elenchi con collegamenti singoli sono probabilmente l’approccio più rispettoso dell’ambiente ed efficiente per l’implementazione di stack dinamici. Usiamo il metodo di categoria e oggetto di Python OOP per creare elenchi collegati in Python. Ora abbiamo alcune funzionalità a nostra disposizione in Python che possono essere utili nell’implementazione dello stack, corrispondenti a getSize(), isEmpty(), push(n) e pop(). Diamo un’occhiata a come ognuna di queste funzionalità aiuta nell’implementazione di uno stack.

#Node creation
class Node:
	def __init__(self, worth):
		self.worth = worth
		self.subsequent = None

#Stack creation
class Stack:
    #Stack with dummy node
	def __init__(self):
		self.head = Node("head")
		self.dimension = 0

	#  For string illustration of the stack
	def __str__(self):
		val = self.head.subsequent
		present = ""
		whereas val:
			present += str(val.worth) + " , "
			val = val.subsequent
		return present[:-3]

	# Retrieve the scale of the stack
	def getSize(self):
		return self.dimension

	# Verify if the stack is empty
	def isEmpty(self):
		return self.dimension == 0

	# Retrieve the highest merchandise of the stack
	def peek(self):
		# Verify for empty stack.
		if self.isEmpty():
			elevate Exception("That is an empty stack")
		return self.head.subsequent.worth

	# Push operation
	def push(self, worth):
		node = Node(worth)
		node.subsequent = self.head.subsequent
		self.head.subsequent = node
		self.dimension += 1

	# Pop Operation
	def pop(self):
		if self.isEmpty():
			elevate Exception("Stack is empty")
		take away = self.head.subsequent
		self.head.subsequent = self.head.subsequent.subsequent
		self.dimension -= 1
		return take away.worth


#Driver Code
if __name__ == "__main__":
	stack = Stack()
	n=20
	for i in vary(1, 11):
		stack.push(n)
		n+=5
	print(f"Stack:{stack}")

	for i  in vary(1, 6):
		take away = stack.pop()
		print(f"Pop: {take away}")
	print(f"Stack: {stack}")

Produzione:

Deque vs. Disco

Deque Disco
È consigliabile importare il modulo delle raccolte per l’utilizzo di deque in Python Non è necessario importare alcun modulo esterno per utilizzare un elenco in Python. È una costruzione di dati incorporati
La complessità temporale di deque per le funzioni append() e pop() è O(1) La complessità temporale degli elenchi per le funzioni append() e pop() è O(n)
Sono a doppia estremità, ovvero i componenti potrebbero essere inseriti e lontani da entrambe le estremità È una costruzione single-ended che abilita append() per inserire il componente alla fine della checklist e pop() per togliere il componente finale dalla checklist
Stack con dimensioni maggiori potrebbe essere eseguito in modo semplice ed efficace tramite deques La checklist è appropriata per operazioni a lunghezza fissa e l’implementazione dello stack tramite liste diventa problematica quando la sua dimensione inizia a crescere.

Pile Python e Threading

Python è un linguaggio multi-thread, cioè permette una programmazione che implica il funzionamento in parallelo di un certo numero di componenti di un corso. Usiamo il threading in Python per gestire un numero di thread come eseguire chiamate e compiti contemporaneamente. Python elenca e deques ogni lavoro in un altro modo per un programma con thread. Non vorresti utilizzare elenchi per costruzioni di conoscenza a cui è necessario accedere da un numero di thread poiché non sono thread-safe.

Il tuo programma thread è sicuro con deques fintanto che stai utilizzando esclusivamente append() e pop(). A parte, anche se riuscissi a creare un programma di deque thread-safe, esporrebbe il tuo programma a possibilità di essere utilizzato in modo improprio e darebbe luogo a situazioni di gara in una data di interruzione successiva. Quindi, né l’elenco di controllo né un deque sono eccellenti da nominare quando si affronta un programma con thread. Il modo più semplice per creare uno stack in un ambiente thread-safe è queue.LifoQueue. Siamo liberi di utilizzare le sue strategie in un ambiente intrecciato. Tuttavia, le tue operazioni di stack in queue.LifoQueue potrebbero richiedere un po’ più di tempo a causa della creazione di chiamate thread-safe.

Attenzione: il threading in Python non implica che thread completamente diversi vengano eseguiti su processori totalmente diversi. Se il 100% del tempo della CPU viene già consumato, i thread Python non saranno utili per creare prima il tuo programma. Sarai in grado di passare alla programmazione parallela in questi casi.

A quale implementazione di Stack si dovrebbe pensare?

Quando si affronta un programma senza thread, è meglio optare per un deque. Quando il tuo programma richiede un ambiente thread-safe, scegli LifoQueue fino a quando l’efficienza e la manutenzione del tuo programma non sono estremamente influenzate dal ritmo delle operazioni dello stack.

Ora, la lista di controllo è un po’ pericolosa poiché aumenterebbe i punti di riallocazione della reminiscenza. A parte questo, gli elenchi Python di solito non sono sicuri per gli ambienti multithreading. L’elenco di controllo e le interfacce di deque sono identiche, a parte i punti all’interno dell’elenco di controllo. Pertanto, una deque Python potrebbe essere vista come la più efficace per l’implementazione dello stack.

Conclusione

Ora che potresti essere arrivato alla punta di questo testo, dovresti aver acquisito una comprensione dello stack in Python. La metà più importante è riconoscere le condizioni in cui vale la pena implementare uno stack. Avrai scoperto numerosi metodi per implementare lo stack in Python, quindi riconosci che è importante conoscere le necessità del tuo programma per avere la possibilità di selezionare la scelta di implementazione dello stack più efficace.

Dovresti essere chiaro se stai scrivendo un programma multi-thread o meno. Gli elenchi Python di solito non sono thread-safe, e quindi preferiresti andare per deques in caso di ambienti multi-threading. Lo svantaggio delle operazioni di stack graduali potrebbe essere ignorato fintanto che l’efficienza del programma non diminuisce a causa di questi componenti.

Domande costantemente richieste

Cos’è uno stack Python?

Uno stack è un tipo di costruzione di conoscenza lineare in Python che consente l’archiviazione e il recupero di componenti all’interno del metodo LIFO (Final In First Out).

Sei in grado di creare uno stack in Python?

Certo, creeremo semplicemente uno stack in Python utilizzando liste, LifoQueues o deques. Per uno stack dinamico, puoi creare elenchi collegati singoli con la stessa efficacia in Python per quella materia.

Quando useresti uno stack in Python?

Pila di libri, una pila di scartoffie, una pila di piatti e molti altri., tutte le istanze di utilizzo della pila nel mondo reale. Utilizzerai uno stack in Python ogni volta che cerchi un metodo per vendere al dettaglio e inserire componenti in un metodo LIFO. Supponiamo che uno sviluppatore, impegnato in un editor di frasi nuovo di zecca, debba creare una funzione di annullamento nel punto in cui è necessario tornare indietro tanto quanto è necessario il primo movimento. Per un tale stato di cose, l’utilizzo di uno stack Python potrebbe essere la cosa migliore per archiviare le azioni dei clienti coinvolti nell’editor di frasi.

Che cos’è uno stack nell’istanza di Python?

Esempio: un file di studiosi che entrano in un corridoio per un seminario, il luogo in cui devono allontanarsi dal corridoio con un metodo LIFO.

Python è full-stack?

Certo, Python potrebbe essere utilizzato in modo molto efficace per la crescita dell’intero stack. Tuttavia, la crescita dello stack completo e lo stack sono due problemi del tutto. Per saperne di più sullo stack in Python, torna all’articolo di cui sopra.

Come faccio a sapere se uno stack Python è pieno?

Quando si implementa uno stack all’interno del tipo di elenchi o elenchi collegati, è necessario utilizzare scale() perform per verificare se lo stack ha raggiunto il limite massimo. Avrai la metodologia complete() in LifoQueue per verificare se lo stack è pieno o meno.



The Ultimate Managed Hosting Platform

Source link

Continue Reading

Ultime notizie

Imitare la funzione dei recettori Ruffini utilizzando una pelle artificiale bio-ispirata – The Latest in Artificial Intelligence | Robotica AI

Published

on

Mimicking the function of Ruffini receptors using a bio-inspired artificial skin

The Ultimate Managed Hosting Platform

Stack è una sorta di lineare struttura dati che consente l’archiviazione e l’ingresso di conoscenze rispettose dell’ambiente. Poiché il significato letterale di stack significa, questa costruzione della conoscenza si basa sulla logica di memorizzare i componenti uno sopra l’altro. Ci sono molti esempi del mondo reale della pila della nostra vita quotidiana, corrispondenti a una pila di piatti, una pila di appunti, una pila di indumenti e molti altri. Come ogni altro linguaggio di programmazione rispettoso dell’ambiente, Python consente inoltre un’implementazione pulita dello stack e numerose diverse costruzioni di conoscenza. Immediatamente, in questo articolo, studieremo lo stack Python e come implementarlo.

Cos’è Stack in Python?

Stack è una costruzione di conoscenza lineare che funziona secondo il precetto di “Final In First Out (LIFO). Ciò significa che il componente che entra per primo nello stack esce finale. Il periodo di tempo che utilizziamo per inviare il meteo a uno stack è chiamato “Push”, mentre il periodo di tempo per eliminare il meteo da uno stack è chiamato “Pop”. Pertanto, diremo che poiché uno stack ha solo un traguardo aperto, push e popping non possono avvenire contemporaneamente. Di seguito è stata mostrata un’illustrazione grafica dell’operazione PUSH e POP all’interno dello stack:

Illustrazione pittorica di stack, push e pop

Il tipo di dati integrato di Python che utilizziamo per implementare Python è la checklist di Python. Inoltre, per esercitare operazioni PUSH e POP su uno stack, utilizziamo append() e pop() perform della checklist Python.

Get your arms on the Python Stack course and study extra about it.

Strategie di Stack

Probabilmente le strategie più fondamentali relative a uno Stack in Python sono le seguenti:

  • spingere(n)– Questa può essere una metodologia di stack definita dall’utente utilizzata per inserire un componente nello stack. Il componente da spingere viene consegnato nella sua argomentazione.
  • pop()– Vogliamo che questa metodologia tolga il componente più in alto dallo stack.
  • è vuoto()– Vogliamo che questa metodologia verifichi se lo stack è vuoto o meno.
  • dimensione()– Vogliamo che questa metodologia ottenga la scala dello stack.
  • primo ()– Questa metodologia di impilamento può essere utilizzata per restituire il riferimento al componente più in alto o all’ultimo componente inserito in uno stack.

Funzionalità relative a Python Stack

Ci sono un sacco di funzioni utili in Python che ci aiutano a prenderci cura di uno stack in modo efficace. Diamo una breve occhiata a queste caratteristiche –

  • len()– Questa metodologia dello stack viene utilizzata per restituire la scala dello stack. Questa esecuzione può essere utilizzata all’interno della definizione della metodologia isempty() in uno stack Python.
  • append(n)– Questa esecuzione Python viene utilizzata per inserire un componente nello stack. Il componente da spingere viene consegnato nella sua argomentazione.
  • pop()– Questa metodologia, correlata agli elenchi Python, viene utilizzata per eliminare il componente più in alto dallo stack.

Implementazione di Stack

Esistono 4 metodi con cui eseguiremo l’implementazione di uno stack in Python-

  • lista di controllo
  • collezioni.deque
  • coda.LifoQueue
  • Lista di controllo a collegamento singolo

Di questi tre, l’approccio più semplice e preferito per implementare uno stack in Python è la checklist. Vediamo l’implementazione di uno stack in Python utilizzando le liste.

Implementazione utilizzando il record

# Stack Creation
def create_stack():
    stack = checklist()            #declaring an empty checklist
    return stack


# Checking for empty stack
def Isempty(stack):
    return len(stack) == 0


# Inserting gadgets into the stack
def push(stack, n):
    stack.append(n)
    print("pushed merchandise: " + n)


# Elimination of a component from the stack
def pop(stack):
    if (Isempty(stack)):
        return "stack is empty"
    else:
        return stack.pop()

# Displaying the stack components
def present(stack):
    print("The stack components are:")
    for i in stack:
        print(i)
        
stack = create_stack()
push(stack, str(10))
push(stack, str(20))
push(stack, str(30))
push(stack, str(40))
print("popped merchandise: " + pop(stack))
present(stack)

Produzione:

Tuttavia, il soggetto del ritmo si trasforma in una limitazione significativa proprio qui quando si affronta uno stack in aumento. I gadget in un elenco vengono salvati uno dopo l’opposto contenuto nella reminiscenza. Pertanto, se lo stack cresce più del blocco di reminiscenza assegnato alla checklist, Python deve eseguire alcune nuove allocazioni di reminiscenza, portando ad alcuni append() che impiegano molto più tempo del resto durante la chiamata.

Implementazione utilizzando collections.deque

Useremo inoltre la classe deque del modulo delle raccolte Python per implementare uno stack. Poiché una coda deque o double-ended ci consente di inserire ed eliminare componenti da ogni ingresso e lato posteriore, è forse più appropriato a volte quando richiediamo prima operazioni append() e pop().

from collections import deque  

def create_stack():  
    stack = deque()    #Creating empty deque
    return stack 
  
# PUSH operation utilizing append()
def push(stack, merchandise):
    stack.append(merchandise)

  
#POP operation
def pop(stack):
    if(stack):
        print('Component popped from stack:')
        print(stack.pop())
    else:
        print('Stack is empty')
    

#Displaying Stack
def present(stack):
    print('Stack components are:')
    print(stack)
    
new_stack=create_stack()
push(new_stack,25)
push(new_stack,56)
push(new_stack,32)
present(new_stack)

pop(new_stack)
present(new_stack)

Produzione:

Implementazione utilizzando queue.LifoQueue

Il modulo coda di Python è costituito da una coda LIFO. Una coda LIFO non è altro che uno stack. Pertanto, implementeremo semplicemente e con successo uno stack in Python utilizzando il modulo coda. Per un LifoQueue, abbiamo alcune funzionalità che possono essere utili nell’implementazione dello stack, corrispondenti a qsize(), full(), empty(), put(n), get() come visto nel seguente pezzo di codice. Il parametro della dimensione massima di LifoQueue definisce il limite delle cose che lo stack può mantenere.

from queue import LifoQueue
  
# Initializing a stack
def new():
    stack = LifoQueue(maxsize=3)   #Fixing the stack dimension
    return stack

#PUSH utilizing put(n) 
def push(stack, merchandise):
    if(stack.full()):                      #Checking if the stack is full
        print("The stack is already full")
    else:
        stack.put(merchandise)
        print("Dimension: ", stack.qsize())     #Figuring out the stack dimension

#POP utilizing get()
def pop(stack):
    if(stack.empty()):              #Checking if the stack is empty
        print("Stack is empty")
    else:
        print('Component popped from the stack is ', stack.get())         #Eradicating the final component from stack
        print("Dimension: ", stack.qsize())

stack=new()
pop(stack)
push(stack,32)
push(stack,56)
push(stack,27)
pop(stack)

Produzione:

Implementazione utilizzando una checklist collegata singolarmente

Gli elenchi con collegamenti singoli sono probabilmente l’approccio più rispettoso dell’ambiente ed efficiente per l’implementazione di stack dinamici. Usiamo il metodo di categoria e oggetto di Python OOP per creare elenchi collegati in Python. Ora abbiamo alcune funzionalità a nostra disposizione in Python che possono essere utili nell’implementazione dello stack, corrispondenti a getSize(), isEmpty(), push(n) e pop(). Diamo un’occhiata a come ognuna di queste funzionalità aiuta nell’implementazione di uno stack.

#Node creation
class Node:
	def __init__(self, worth):
		self.worth = worth
		self.subsequent = None

#Stack creation
class Stack:
    #Stack with dummy node
	def __init__(self):
		self.head = Node("head")
		self.dimension = 0

	#  For string illustration of the stack
	def __str__(self):
		val = self.head.subsequent
		present = ""
		whereas val:
			present += str(val.worth) + " , "
			val = val.subsequent
		return present[:-3]

	# Retrieve the scale of the stack
	def getSize(self):
		return self.dimension

	# Verify if the stack is empty
	def isEmpty(self):
		return self.dimension == 0

	# Retrieve the highest merchandise of the stack
	def peek(self):
		# Verify for empty stack.
		if self.isEmpty():
			elevate Exception("That is an empty stack")
		return self.head.subsequent.worth

	# Push operation
	def push(self, worth):
		node = Node(worth)
		node.subsequent = self.head.subsequent
		self.head.subsequent = node
		self.dimension += 1

	# Pop Operation
	def pop(self):
		if self.isEmpty():
			elevate Exception("Stack is empty")
		take away = self.head.subsequent
		self.head.subsequent = self.head.subsequent.subsequent
		self.dimension -= 1
		return take away.worth


#Driver Code
if __name__ == "__main__":
	stack = Stack()
	n=20
	for i in vary(1, 11):
		stack.push(n)
		n+=5
	print(f"Stack:{stack}")

	for i  in vary(1, 6):
		take away = stack.pop()
		print(f"Pop: {take away}")
	print(f"Stack: {stack}")

Produzione:

Deque vs. Disco

Deque Disco
È consigliabile importare il modulo delle raccolte per l’utilizzo di deque in Python Non è necessario importare alcun modulo esterno per utilizzare un elenco in Python. È una costruzione di dati incorporati
La complessità temporale di deque per le funzioni append() e pop() è O(1) La complessità temporale degli elenchi per le funzioni append() e pop() è O(n)
Sono a doppia estremità, ovvero i componenti potrebbero essere inseriti e lontani da entrambe le estremità È una costruzione single-ended che abilita append() per inserire il componente alla fine della checklist e pop() per togliere il componente finale dalla checklist
Stack con dimensioni maggiori potrebbe essere eseguito in modo semplice ed efficace tramite deques La checklist è appropriata per operazioni a lunghezza fissa e l’implementazione dello stack tramite liste diventa problematica quando la sua dimensione inizia a crescere.

Pile Python e Threading

Python è un linguaggio multi-thread, cioè permette una programmazione che implica il funzionamento in parallelo di un certo numero di componenti di un corso. Usiamo il threading in Python per gestire un numero di thread come eseguire chiamate e compiti contemporaneamente. Python elenca e deques ogni lavoro in un altro modo per un programma con thread. Non vorresti utilizzare elenchi per costruzioni di conoscenza a cui è necessario accedere da un numero di thread poiché non sono thread-safe.

Il tuo programma thread è sicuro con deques fintanto che stai utilizzando esclusivamente append() e pop(). A parte, anche se riuscissi a creare un programma di deque thread-safe, esporrebbe il tuo programma a possibilità di essere utilizzato in modo improprio e darebbe luogo a situazioni di gara in una data di interruzione successiva. Quindi, né l’elenco di controllo né un deque sono eccellenti da nominare quando si affronta un programma con thread. Il modo più semplice per creare uno stack in un ambiente thread-safe è queue.LifoQueue. Siamo liberi di utilizzare le sue strategie in un ambiente intrecciato. Tuttavia, le tue operazioni di stack in queue.LifoQueue potrebbero richiedere un po’ più di tempo a causa della creazione di chiamate thread-safe.

Attenzione: il threading in Python non implica che thread completamente diversi vengano eseguiti su processori totalmente diversi. Se il 100% del tempo della CPU viene già consumato, i thread Python non saranno utili per creare prima il tuo programma. Sarai in grado di passare alla programmazione parallela in questi casi.

A quale implementazione di Stack si dovrebbe pensare?

Quando si affronta un programma senza thread, è meglio optare per un deque. Quando il tuo programma richiede un ambiente thread-safe, scegli LifoQueue fino a quando l’efficienza e la manutenzione del tuo programma non sono estremamente influenzate dal ritmo delle operazioni dello stack.

Ora, la lista di controllo è un po’ pericolosa poiché aumenterebbe i punti di riallocazione della reminiscenza. A parte questo, gli elenchi Python di solito non sono sicuri per gli ambienti multithreading. L’elenco di controllo e le interfacce di deque sono identiche, a parte i punti all’interno dell’elenco di controllo. Pertanto, una deque Python potrebbe essere vista come la più efficace per l’implementazione dello stack.

Conclusione

Ora che potresti essere arrivato alla punta di questo testo, dovresti aver acquisito una comprensione dello stack in Python. La metà più importante è riconoscere le condizioni in cui vale la pena implementare uno stack. Avrai scoperto numerosi metodi per implementare lo stack in Python, quindi riconosci che è importante conoscere le necessità del tuo programma per avere la possibilità di selezionare la scelta di implementazione dello stack più efficace.

Dovresti essere chiaro se stai scrivendo un programma multi-thread o meno. Gli elenchi Python di solito non sono thread-safe, e quindi preferiresti andare per deques in caso di ambienti multi-threading. Lo svantaggio delle operazioni di stack graduali potrebbe essere ignorato fintanto che l’efficienza del programma non diminuisce a causa di questi componenti.

Domande costantemente richieste

Cos’è uno stack Python?

Uno stack è un tipo di costruzione di conoscenza lineare in Python che consente l’archiviazione e il recupero di componenti all’interno del metodo LIFO (Final In First Out).

Sei in grado di creare uno stack in Python?

Certo, creeremo semplicemente uno stack in Python utilizzando liste, LifoQueues o deques. Per uno stack dinamico, puoi creare elenchi collegati singoli con la stessa efficacia in Python per quella materia.

Quando useresti uno stack in Python?

Pila di libri, una pila di scartoffie, una pila di piatti e molti altri., tutte le istanze di utilizzo della pila nel mondo reale. Utilizzerai uno stack in Python ogni volta che cerchi un metodo per vendere al dettaglio e inserire componenti in un metodo LIFO. Supponiamo che uno sviluppatore, impegnato in un editor di frasi nuovo di zecca, debba creare una funzione di annullamento nel punto in cui è necessario tornare indietro tanto quanto è necessario il primo movimento. Per un tale stato di cose, l’utilizzo di uno stack Python potrebbe essere la cosa migliore per archiviare le azioni dei clienti coinvolti nell’editor di frasi.

Che cos’è uno stack nell’istanza di Python?

Esempio: un file di studiosi che entrano in un corridoio per un seminario, il luogo in cui devono allontanarsi dal corridoio con un metodo LIFO.

Python è full-stack?

Certo, Python potrebbe essere utilizzato in modo molto efficace per la crescita dell’intero stack. Tuttavia, la crescita dello stack completo e lo stack sono due problemi del tutto. Per saperne di più sullo stack in Python, torna all’articolo di cui sopra.

Come faccio a sapere se uno stack Python è pieno?

Quando si implementa uno stack all’interno del tipo di elenchi o elenchi collegati, è necessario utilizzare scale() perform per verificare se lo stack ha raggiunto il limite massimo. Avrai la metodologia complete() in LifoQueue per verificare se lo stack è pieno o meno.



The Ultimate Managed Hosting Platform

Source link

Continue Reading

Trending