text:
Remarkable Escapes from Peril
Por Samuel Manning
injury when a cart-wheel went over his arm. The cause which led to his preservation, was the fact of one of the causeway stones being higher than the others around it, and the wheel in consequence being lifted up by it, passed over Mr. Cecil without crushing him.
In the instances of the preserving care of God already adduced, that care has been exercised on occasions when the danger impending was beheld by his watchful eye alone, and they whose lives were threatened were unconscious of it. But it is in answer to fervent and believing prayer that we are warranted to expect deliverances. As to the mode in which prayer is answered without disturbing the natural laws of the world it is unnecessary to speak again, as we have already alluded to the subject in the introduction to this work. His command niakes the duty clear, and his promise makes the answer certain ; " Call upon me in the day of trouble : I will deliver thee, and thou shalt glorify me." A few illustrative instances will set this truth more clearly and forcibly before us.
Our first illustration will be one of an answer vouchsafed to prayer in its lowest form, if we may so express it-prayer wrung by extreme
A few years
danger from lips unaccustomed to utter it, but mercifully listened to by Him who waits to be gracious. The incident is narrated by the rev. H. Cheever, of Americà. ago, the captain of a whaler cruising in the Pacific despatched two out of his three boats in pursuit of a whale. They were very speedily drawn by it out of sight of the ship. Another whale having been seen, the captain ordered the remaining boat to be lowered, and with the remainder of the crew sprang into it, leaving only a man and two boys in charge of the vessel. Having harpooned this monster of the deep, they were carried by it with fearful velocity to a distance of fifteen miles from where their ship lay. The whale then, wrought into frenzy by the pain of the wound, and his inability to detach himself from the weapon, or. shake off his pursuers, rushed upon the boat, struck it in the centre of the keel, dashed it into atoms, plunged into the deep again, and disappeared. The captain and the crew were now in the water, clinging to the scattered fragments of the demolished boat. They were, as we have mentioned, fifteen miles from the ship, and could not be seen from it. The other boats were gone they knew not whither ; every
chance or possibility of escape seemed cut off, and they were left to a watery grave. twelve at noon. The lours of one, two, three, four, five, six, passed slowly away, and still they were floating, almost exhausted, upon the heaving billows of the Pacific.
"Oh! how fervently I prayed," said one of these mariners, when afterwards relating the scene,
" that God would in some way providentially interpose and save our lives! I thought of my wife, of my little children, of my prayerless life, of the awful account I had to render at the bar of God for grieving the Spirit and neglecting the Saviour. All the horrors of this dreadful death were forgotten in the thought, that in one short hour I was to render up an account to God for years of ingratitude and disobedience."
The sun had now disappeared behind the distant waves, and the darkening shades of a dreary night were settling down over the ocean. Just then they descried, dim in the dusky distance, one of the absent boats returning to the ship. It was, however, far off, apparently beyond the reach of their loudest outcries. Impeiled by the energies of despair, they simultaneously raised a shout, which blended
with the wash of the waves and the sighing of the breeze ; still, however, the boat continued her course. Again they raised another shout, and it too was unavailing.
The shades of night were deepening, and the boat was rapidly passing by them; almost frenzied at their terrible condition, they raised another cry.
The sound of that distant shriek fell faintly upon the ears of the boatmen, and they rested on their oars.
Another shout, which almost lacerated their throats as they uttered it, and the boat turned in pursuit. They were taken nearly lifeless from the water, and carried to the ship. In this very striking narrative, we cannot but observe that the cry was heard in heaven before it was heard on earth. They prayed when there was no helper near save God, and "he inclined unto them, and heard their cry."
Our next illustration will also be drawn from the perils of the deep, but it illustrates another fact besides the efficacy of prayer in gaining deliverance. It shows how prayerful trust in God can give tranquillity and peace in the hour of utmost peril. The incident in question is extracted from a little volume entitled, " God our Refuge," and is the narrative of a home
ward voyage across the Atlantic by Leonard Strong. It is too long for transcription into our pages, or we would gladly have given it entire. The author being about to sail for England in the steamer "T—" was, in common with the other passengers, startled to hear that the vessel in which they were to embark had been lying for eight days on a reef of rocks off Cuba, by which nearly twenty feet of her keel had been torn away.
She had, however, been repaired and pronounced seaworthy. " There was still general consternation among the passengers, and much question as to the safety of proceeding in such a crippled ship. For myself, I felt much perplexity as to my path, and whether I should construe this as a providential hindrance to delay my voyage, or simply an occasion for the exercise of faith in God for special preservation. Giving myself to prayer, I felt a calm persuasion in my mind that all was well, and ordered for our good and his glory." This was no wild presumption on the part of the writer, for so secure was the steamer now considered that a valuable freight of silver and pearls was placed on baard of it.
It appeared that the rent in the vessel's keel had been repaired by a water-tight deck being


text:
Some matchups worth cheering
HIGH SCHOOL football isn't just about what's on the gridiron. Above, Garden Grove High's spirit ladies stand tall (Orange County Tribune photo).
There's an old coaching adage: "If you want to be the best, you have to beat the best."
Some local team high school football teams will get the chance to measure themselves against ranked teams this week.
Edison (2-2) is rated seventh in Orange County and will host San Clemente (3-1), the 10th-ranked team in a non-league contest Friday night at Sheue Field at Huntington Beach High.
Orange (1-2), rated 14th, will take on Capistrano Valley (3-1), the 17th-ranked team on Friday. Garden Grove (2-1) will host El Toro (4-0) on Friday. The Chargers are rated 22nd.
But some games seem quite the opposite. Buena Park (0-4) will play Pacifica (3-0) on Thursday in what might be the blowout of the week.
Edison's Chargers still have the juice
As they have been all season, Edison High's football team is ranked number one in The Tribune's High Five for area schools. Moving into second place is Orange, with Huntington Beach staying in third. Pacifica has settled into fourth and Garden Grove is back in the Five, in fifth.
Also looking strong are Rancho Alamitos, Santiago and Westminster.
Standouts on the gridiron
Here are some of the eye-catching performances in area high school football last week.
Parker Awad of Edison passed for 346 yards and three touchdowns in the Chargers' win over Palos Verdes.
Dominick Brito of Garden Grove returned an interception 101 yards and a punt 55 yards – both for touchdowns – in the Argonauts' win over Gahr. He also caught four passes for 41 yards and ended up with 283 all-purpose yards.
Darius Cowens of Pacifica passed for 299 yards and a touchdown for the Mariners in their win over Canyon. He also rushed for 158 yards and three scores.
Ed "Jun" Ramos of Pacifica rushed for 177 yards and four touchdowns.
Blake Miller of Huntington Beach passed for 324 yards and two scores in the Oilers' loss to El Toro.
Daniel Gonzales of Santiago passed for 131 yards and two touchdowns in the Cavaliers' win over Estancia.
Vany Rodriguez of Garden Grove passed for 174 yards and two scores as the Argos beat Gahr.
Week Four's high school football menu
Buena Park (0-4) at Pacifica (3-0) at Bolsa Stadium
Bolsa Grande (2-1) at Saddleback (2-1)
Western (2-2) at Artesia (0-3)
Marina (1-3) at Huntington Beach (2-2)
El Toro (4-0) at Garden Grove (2-1)
San Clemente (3-1) at Edison (2-2)
Savanna (1-3) at Westminster (3-0)
Loara (2-2) at Anaheim (0-3) at Glover Stadium
Walnut (1-2) at Ocean View (1-3)
La Quinta (0-3) at Estancia (1-2)
Los Amigos (2-1) at Costa Mesa (1-2)
Santiago (3-0) at Magnolia (2-1)
Orange (1-2) at Capistrano Valley (3-1)
Godinez (1-2) at Rancho Alamitos (2-1) at Bolsa Stadium.
As always, game locations, opponents, times, dates, etc. are subject to change without notice. If you're planning to attend, check with the school.
Ten teams are rated terrific
In this week's polls from the CIF-SS for girls' volleyball and boys' water polo, nine local teams are noted.
In v-ball, Huntington Beach isn't ranked in Divisions 1 and 2, but received some votes. Edison is eighth in Division 3. In Division 8, Bolsa Grande is sixth and Garden Grove ninth.
In polo, Huntington Beach is first in Division 1. Edison is fourth in Division 2 and Marina places fourth in Division 4. Los Amigos is unranked in Division 5, but received some votes. In Division 6, Westminster is second and La Quinta seventh.
"Prep Sport Spotlight" is posted on Tuesdays during the high school athletic year. Coaches, parents, fans and players are encouraged to send us news, results, rosters, photos, etc. to orangecountytribune@gmail.com .
Categories: High school sports
Tagged as: Edison High School, Garden Grove High School, Orange High School, Pacifica, Pacifica High School, Prep Sport Spotlight, Skyboxes
How to pay for Biden plan
COVID stats show good news

redpajama_set_name: RedPajamaCommonCrawl


text:
Cyber Making Headlines in the Tennessee Valley
<< First < Prev 1 2 3 Next > Last >>
CMMC with Katie Arrington
Tuesday, November 24, 2020 1:07 PM | Anonymous member (Administrator)
CMMC stands for "Cybersecurity Maturity Model Certification". The CMMC will encompass multiple maturity levels that ranges from "Basic Cybersecurity Hygiene" to "Advanced/Progressive". The intent is to incorporate CMMC into Defense Federal Acquisition Regulation Supplement (DFARS) and use it as a requirement for contract award. The official website can be found at https://www.acq.osd.mil/cmmc/
This past week, several Cyber Huntsville Board members were on a TEAMS call with the creator of the CMMC, Katie Arrington. She provided an overview of the Cyber Resiliency Project that included online training modules and CMMC guide.
Training: https://projectspectrum.io/#!/pilotProgram
CMMC Guide: https://projectspectrum.io/#!/abtcmmc
The DOD is planning to migrate to the new CMMC framework in order to assess and enhance the cybersecurity posture of the Defense Industrial Base (DIB). The CMMC is intended to serve as a verification mechanism to ensure appropriate levels of cybersecurity practices and processes are in place to ensure basic cyber hygiene as well as protect controlled unclassified information (CUI) that resides on the Department's industry partners' networks.
Ms. Arrington is asking for input into the Defense Federal Acquisition Regulation Supplement: Assessing Contractor Implementation of Cybersecurity Requirements (DFARS Case 2019-D041) https://www.federalregister.gov/documents/2020/09/29/2020-21123/defense-federal-acquisition-regulation-supplement-assessing-contractor-implementation-of available for public comment by November 30th.
We encourage all Cyber Huntsville members, and the entire Tennessee Valley community, to submit comments to the CMMC/DFARS Interim Rule.
Read more • Add comment
2020 NASA Space Apps Hackathon Challenge
Sunday, September 13, 2020 9:23 PM | Anonymous member
Alabama A&M University will be hosting the 2020 NASA Space Apps Hackathon Challenge this year on October 2-4. The event will be held virtually due to the Covid-19 pandemic. Dr. Pearson at Alabama A&M would like to invite interested members of Cyber Huntsville and Cyber Huntsville member companies, other academic institutions and partners to serve as either a judge for the competition, or serve as a mentor for the teams participating in the challenge. The mentor will provide assistance to the team by answering questions and providing guidance on completing the challenges.
The judging will take place on Sunday October 4th from 12pm to 2:30pm. The mentors will be needed for both Saturday the 3rd and Sunday the 4th. NASA will soon be providing Dr. Pearson more details on judging and mentor responsibilities. As soon as he receives them, these details will be provided.
Register Here: https://2020.spaceappschallenge.org/locations/huntsville-al-at-alabama-am/
Contact Dr. Ed Pearson at ed.pearson@aamu.edu for questions.
DC BLOX/HSV Utilities Partnership
DC Blox recently held an event with Huntsville Utilities on August 28th, 2020. The panel discussed why the partnership between DC BLOX and Huntsville Utilities is so important to Huntsville businesses. The event can be viewed here: https://vimeo.com/453820063
CMMC From The Subs Perspective
Thursday, August 27, 2020 9:27 AM | Anonymous member
Simple Helix is partnering with the North Alabama Chapter of the Information Systems Security Association (NAC-ISSA) to host a virtual discussion panel event. During the event, the CMMC discussion will be examined through the lens of the subcontractors that are currently working towards CMMC compliance. A panel of 3 small contractors and subcontractor representatives will be moderated by a Simple Helix Subject Matter Expert (SME) as they elaborate and discuss their journey to compliance.
The speakers:
• Moderator: Scott McDaniel – Vice President of Technology, Simple Helix
• Panel Member: Josh Reinoehl – Technical Manager, Canvas Inc.
• Panel Member: Lloyd Sanders – CTO, Offset Strategic Services
• Panel Member: Michael Rawls – GIS PM/AFSO/ITPSO, Ethic Tech
The subs will be asked questions like:
• Why did you decide to work towards CMMC compliance now?
• What are some of the hurdles you've been able to overcome regarding CMMC?
• What are the tools you've chosen to use to become compliant and why?
• How has this new compliance standard changed the way you operate?
Date – Tuesday, September 15, 2020
Time – 11:30am to 12:30pm
To explore these questions and gain insight on the subcontractor's journey to CMMC Compliance, please register.
Cyber-Attack Downs Alabama County's Network
Monday, July 20, 2020 7:53 PM | Anonymous member
From: Info-Security Magazine 9 July 2020
A suspected ransomware attack has caused the temporary closure of an Alabama county's computer network.
Chilton County implemented a shutdown after being targeted by a suspected ransomware attack on the morning of July 7. County Commission Chairman Joseph Parnell announced the incident on the social media network Facebook.
"The incident has caused a temporary disruption to the County's computer records systems including the tag office and probate court records," wrote Parnell.
"Persons needing services provided by our various departments should check with the clerks in the particular department before coming to the courthouse to ensure that needed records are accessible."
As a result of the attack, local records required by the courthouse in the performance of its regular services have been rendered unavailable.
In a phone interview with the Clanton Advertiser, Parnell said an investigation was underway to determine the severity of the cyber-incident. The county servers and computers in several departments have been closed in a bid to limit the spread of any malware infection that may have occurred.
"Our databases and computers are shut down while the cyber guys are trying to figure out if and what the extent was of the intrusion," said Parnell.
The chairman said that until the severity of the attack had been diagnosed, the county was assuming the worst.
Parnell said: "It could be very minor, and it could be very serious, but we have to treat this like it is extremely serious until we know otherwise."
A cyber-attack was suspected when the county's computers started behaving in a way that was out of character. Parnell said that Chilton's employees noticed "their computers were not functioning normally. They were sluggish, and some of their applications looked different."
Employees reported the discrepancies to the local IT team, which then shut down the county's internal network.
"We have a cyber-policy in place and have hired a firm of professional IT people out of New York that is going to come in and assess the system," Parnell said.
The cyber-branch of the FBI and the Alabama Attorney General's Office have been notified of the incident.
https://www.infosecurity-magazine.com/news/cyberattack-downs-alabama-countys/
CYBERSECURITY & CYBER OPERATIONS Senate Committee Wants More Cyber Pilot Programs
Wednesday, June 24, 2020 10:30 AM | Anonymous member
The Senate Armed Services Committee wants to add new responsibilities to the Pentagon's Principal Cyber Advisor as part of a broader effort to ensure cyber forces can meet new challenges.
The committee released a summary June 11 of the annual defense policy bill for fiscal year 2021. The bill, which passed the committee June 10, also adopts several recommendations made by the Cyberspace Solarium Commission, a bipartisan organization created in 2019 to develop a multipronged U.S. cyber strategy.
Among items the panel approved is giving the Principal Cyber Advisor more responsibility related to integration and coordination to ensure that DoD's cyber policies are coherent and cohesive.
Here is a breakdown of other key cyber-related items in the bill:
The bill includes several provisions to improve the way DoD procures cyber equipment as well as to improve the Congressional oversight of those programs.
The solarium commission had recommended DoD write a report on the direction and control of budgets related to cyber forces. New language in the Senate committee's version takes that recommendation and is aims at ensuring flexibility and agility to control acquisition.
The bill also requires the Department of Defense to kick off pilot programs, demonstrations and/or plans in several areas. These include speed-based cybersecurity capability metrics to measure DoD performance and effectiveness, interoperability and automated orchestration of cybersecurity systems, addressing network timing and inconsistencies and integration of user activity monitoring and cybersecurity systems.
The draft bill also includes two provisions aimed changing how some cyber funds are spent. First, it authorizes increased funds for Air Force and Army operation and maintenance funds to provide the cyber mission force with additional resources to access, operate, and train as required by increased operational demands. Those increases are $25 million and $5 million, respectively.
Second, the bill allows Defense leaders to use these funds for rapid creation, testing and fielding of cyber capabilities to respond more quickly to threats.
This builds upon last year's defense policy law that codified use of these funds for "rapid creation, testing, fielding, and operation of cyber capabilities that would be developed and used within the 1-year appropriation period." The Air Force is already using these funds in this manner.
Off the bench
The bill includes several provisions focused on National Guard and Reserve cyber forces. DoD has typically thought of those teams as critical resources at the state, local and national level to augment the active duty force.
Specially, the Senate bill takes two recommendations from the solarium commission requiring DoD to conduct a review of National Guard responses to cyberattacks and an evaluation of cyber reserve force options to provide a surge capability.
The bill also authorizes a pilot program to prepare the Guard to provide cyber assistance remotely in the event of cyberattacks.
Assessing the force
The committee also takes aim at a couple of force structure issues. One recommendation from the solarium commission included requiring DoD to provide a force structure assessment in the quadrennial cyber posture review.
Solarium commissioners, and members of Congress, are concerned that U.S. Cyber Command's cyber mission force might not be prepared to take on today's threats.
The bill also aims to help DoD better retain its cyber talent. Specifically, Senators want to give Cyber Command the same hiring authority for technical talent as the Defense Advanced Research Projects Agency, Strategic Capabilities Office or the Joint Artificial Intelligence Center. This will allow Cyber Command to offer more competitive pay.
Additionally, the bill requires a provision requiring more regular updates to Congress on cyber operations while also requiring an assessment of gaps between the cyber mission force and cybersecurity service providers.
The Senate panel's bill will next head to the full Senate before being reconciled with the House version. The House Armed Services will mark up its version June 22.
Senate Committee Wants More Cyber Pilot Programs
Tuesday, June 16, 2020 8:35 AM | Anonymous member (Administrator)
The committee released a summary June 11 of the annual defense policy bill for fiscal year 2021. The bill, which passed the committee June 10, also adopts several recommendations made by the Cyberspace Solarium Commission, a bipartisan organization created in 2019 to develop a multi-pronged U.S. cyber strategy.
Following is a breakdown of other key cyber-related items in the bill:
Specially, the Senate bill takes two recommendations from the solarium commission requiring DoD to conduct a review of National Guard responses to cyber attacks and an evaluation of cyber reserve force options to provide a surge capability.
The bill also authorizes a pilot program to prepare the Guard to provide cyber assistance remotely in the event of cyber attacks.
http://feedproxy.google.com/~r/fifth-domain/home/~3/dbdo6OD_yKI/
2020 HATCH Hudson Alpha Tech Challenge
Friday, March 06, 2020 5:00 PM | Anonymous member
Powered by HudsonAlpha Institute for Biotechnology, Urban Engine and Acclinate Genetics
Description: The HudsonAlpha Tech Challenge is a unique event to engage the development community and take on challenges in life sciences using business strategy, software development and technology.
Goal: Inspire creativity through collaboration, and energize the current and next generation of problem-solvers to conceive and construct innovative solutions to biotech challenges.
$5,000 in prize money is up for grabs!
Date: March 6-8, 2020
Location: HudsonAlpha Institute for Biotechnology, Paul Propst Center, 800 Hudson Way NW, Huntsville, AL
Cost: $10/participant
https://www.eventbrite.com/e/2020-hatch-hudsonalpha-tech-challenge-tickets-84916091315
Former National Cyber Summit and FBI Deputy Director Speaks on Indictment of Cybercriminals from China's People's Liberation Army
Thursday, February 13, 2020 9:05 AM | Anonymous member (Administrator)
Chinese Military Personnel Charged with Computer Fraud, Economic Espionage and Wire Fraud for Hacking into Credit Reporting Agency Equifax
Indictment Alleges Four Members of China's People's Liberation Army Engaged in a Three-Month Long Campaign to Steal Sensitive Personal Information of Nearly 150 Million Americans
A federal grand jury in Atlanta returned an indictment last week charging four members of the Chinese People's Liberation Army (PLA) with hacking into the computer systems of the credit reporting agency Equifax and stealing Americans' personal data and Equifax's valuable trade secrets.
The nine-count indictment alleges that Wu Zhiyong (吴志勇), Wang Qian (王乾), Xu Ke
(许可) and Liu Lei (刘磊) were members of the PLA's 54th Research Institute, a component of the Chinese military. They allegedly conspired with each other to hack into Equifax's computer networks, maintain unauthorized access to those computers, and steal sensitive, personally identifiable information of approximately 145 million American victims.
"This was a deliberate and sweeping intrusion into the private information of the American people," said Attorney General William P. Barr, who made the announcement. "Today, we hold PLA hackers accountable for their criminal actions, and we remind the Chinese government that we have the capability to remove the Internet's cloak of anonymity and find the hackers that nation repeatedly deploys against us. Unfortunately, the Equifax hack fits a disturbing and unacceptable pattern of state-sponsored computer intrusions and thefts by China and its citizens that have targeted personally identifiable information, trade secrets, and other confidential information."
According to the indictment, the defendants exploited a vulnerability in the Apache Struts Web Framework software used by Equifax's online dispute portal. They used this access to conduct reconnaissance of Equifax's online dispute portal and to obtain login credentials that could be used to further navigate Equifax's network. The defendants spent several weeks running queries to identify Equifax's database structure and searching for sensitive, personally identifiable information within Equifax's system. Once they accessed files of interest, the conspirators then stored the stolen information in temporary output files, compressed and divided the files, and ultimately were able to download and exfiltrate the data from Equifax's network to computers outside the United States. In total, the attackers ran approximately 9,000 queries on Equifax's system, obtaining names, birth dates and social security numbers for nearly half of all American citizens.
The indictment also charges the defendants with stealing trade secret information, namely Equifax's data compilations and database designs. "In short, this was an organized and remarkably brazen criminal heist of sensitive information of nearly half of all Americans, as well as the hard work and intellectual property of an American company, by a unit of the Chinese military," said Barr.
The defendants took steps to evade detection throughout the intrusion, as alleged in the indictment. They routed traffic through approximately 34 servers located in nearly 20 countries to obfuscate their true location, used encrypted communication channels within Equifax's network to blend in with normal network activity, and deleted compressed files and wiped log files on a daily basis in an effort to eliminate records of their activity.
"Today's announcement of these indictments further highlights our commitment to imposing consequences on cybercriminals no matter who they are, where they are, or what country's uniform they wear," said FBI Deputy Director David Bowdich. "The size and scope of this investigation — affecting nearly half of the U.S. population, demonstrates the importance of the FBI's mission and our enduring partnerships with the Justice Department and the U.S. Attorney's Office. This is not the end of our investigation; to all who seek to disrupt the safety, security and confidence of the global citizenry in this digitally connected world, this is a day of reckoning."
The defendants are charged with three counts of conspiracy to commit computer fraud, conspiracy to commit economic espionage, and conspiracy to commit wire fraud. The defendants are also charged with two counts of unauthorized access and intentional damage to a protected computer, one count of economic espionage, and three counts of wire fraud.
The investigation was conducted jointly by the U.S. Attorney's Office for the Northern District of Georgia, the Criminal and National Security Divisions of the Department of Justice, and the FBI's Atlanta Field Office. The FBI's Cyber Division also provided support. Equifax cooperated fully and provided valuable assistance in the investigation.
Assistant U.S. Attorneys Nathan Kitchens, Samir Kaushal, and Thomas Krepp of the Northern District of Georgia; Senior Counsel Benjamin Fitzpatrick of the Criminal Division's Computer Crime and Intellectual Property Section; and Trial Attorney Scott McCulloch of the National Security Division's Counterintelligence and Export Control Section are prosecuting this case. Attorneys with the Office of International Affairs provided critical assistance in obtaining evidence from overseas.
The details contained in the charging document are allegations. The defendants are presumed innocent until proven guilty beyond a reasonable doubt in a court of law.
The year 2020 marks the 150th anniversary of the Department of Justice. Learn more about the history of our agency at www.Justice.gov/Celebrating150Years.
FY 2020 NDAA Conference Report Summary
Monday, December 16, 2019 10:39 AM | Anonymous member
National Defense Authorization Act for Fiscal Year 2020
This year's NDAA charts a consensus national defense policy that continues the restoration of military readiness, implements a National Defense Strategy to confront Russia, China, and other threats around the world, reforms and modernizes Pentagon business systems and bureaucracy, and – most importantly – cares for our troops and their families.
Here are the Cyber Provisions:
The NDAA strengthens congressional oversight of cyber operations, and enhances the Department of Defense's cybersecurity strategy and cyber warfare capabilities. The Conference Report:
Directs the Secretary of Defense to develop a consistent, comprehensive framework to enhance the cybersecurity of the U.S. defense industrial base;
Requires development of metrics for the assessment of the readiness of the Cyber Mission Forces;
Establishes a consortium of universities to advise the Secretary of Defense on cybersecurity matters;
Establishes Principal Cyber Advisors on military cyber force matters for each military service;
Allows the secretaries of the military departments to use up to $3 million in Operation and Maintenance funds to develop cyber operations-peculiar capabilities for the rapid creation, testing, fielding, and operation of cyber capabilities;
Requires the Secretary of Defense to notify the congressional defense committees and describe various operational details of any delegation of authorities from the National Command Authority for military cyberspace operations;
Directs an annual report on military cyberspace operations;
Directs a zero-based review of Department of Defense cyber and information technology personnel;
Mandates a study on improving cyber career paths in the Navy;
Refines the role of the Chief Information Officer in improving enterprise-wide cybersecurity;
Commissions a Defense Science Board study on future cyber warfighting capabilities of Department of Defense;
Directs the Secretary of Defense to conduct a review of the cyber posture of the United States on a quadrennial basis; and
Extends the completion date of the Cyberspace Solarium Commission.
© Cyber Huntsville
PO Box 11971 , Huntsville, AL 35814
info@cyberhuntsville.org


text:
BJP asks Centre to intervene on Sikhs issue in Pak
Author: Staff Reporter
URL: http://www.dailypioneer.com/174475/BJP-asks-Centre-to-intervene-on-Sikhs-issue-in-Pak.html
Bharatiya Janata Party Literature and Publication Cell State president Deepak Vijayvargiya in a statement here on Wednesday said that Central Government should do all comprehensive efforts for getting justice to the Sikhs who have been displaced from the Taliban-affected areas of Pakistan. For this it is must that international pressure be created on Pakistan, he added.
Vijayvargiya said it is the moral responsibility of the Indian Government to fight for the cause of Human Rights of the destitute Sikhs in Pakistan. The Centre should create support of all the commonwealth countries so that the minorities Sikhs could be saved from the barbarous treatment by the Taliban.
Vijayvargiya also said that it is the responsibility of all commonwealth countries, including Pakistan, to create pressure so that the destitute Sikhs could get proper relief and lead a respected life in their country.
He said that the efforts made by the UPA Government in this direction are not satisfying. They just registered protest by just calling the Pakistan High Commission officials. It is necessary India to create international pressure into the issue, he added.


text:
Performance Services is committed to serving others.
At Performance Services, we are committed to stewardship and the idea of giving back in practical ways to support people who are much less fortunate than ourselves. Find out more about some of our efforts in this important area.
Zoe Empowers
Performance Services proudly supports Zoe Empowers, a program designed to equip vulnerable children with tools and training to overcome life-threatening poverty for good. The three-year program provides valuable resources across eight key areas, including food security, secure housing, health & hygiene, education, income generation, child rights, community connections, and spiritual strength. Learn more about the organization and its mission to empower orphaned children.
Haiti Stewardship Project
Our story in Haiti began in 2012 when Performance Services funded homes in a village called Vialet. On the road to Vialet, the mission team's bus broke down near a Food for the Poor-sponsored fishing village. Seeing the village and learning about the work completed there inspired the mission team to serve the people of Gros Mangle the following year. As a result, Casting Hope, a project of Food for the Poor, was born. Since then, Performance Services has completed several important community projects in Gros Mangle, Barriere Battant, La Fosse, and Vialet. Learn more about our work in Haiti.
Bolt for the Heart
Bolt For The Heart has raised nearly $1.1 Million and donated over 900 Automatic External Defibrillators (AEDs) in the Central Indiana area. Performance Services continues its support for Bolt for the Heart's mission. In 2020 Bolt for the Heart's mission is to provide AEDs to all 92 County Sheriff Departments. Performance Services has proudly awarded and supplied 15 Indiana County Sheriffs with an AED device. Learn more about Bolt for The Heart and join us for the upcoming virtual race today: boltfortheheart.com
Tamarindo Foundation
Against a backdrop of rural, post-war violence and a migration crisis, the Tamarindo Foundation, Inc. (TFI) creates opportunities for non-violence, empowerment, and physical well-being in the community of Guarjila, El Salvador. It offers programs focused on enhancing the wellness, education, and capacity of young people and women. The Tamarindo has enabled the transformation of hundreds of group members' lives, generated positive impacts throughout the community, and introduced numerous visitors to the challenges and dignity of daily life in Central America.
The Thoman Learning Center, a center for education and community in Guarjila, was constructed in 2019 and inaugurated in 2020. Tim Thoman and parishioners from St. Pius in Indianapolis attended the inauguration during a trip in February 2020. The Thoman Learning center supports the Tamarindo initiative to develop academic and vocational educational opportunities based on a comprehensive understanding of the Salvadoran economy, making Salvadoran youth job-ready.
Thoman Learning Center Inauguration Facebook Album
Trinity Free Clinic
The mission of the Trinity Free Clinic is to provide quality free medical, dental, and health services with dignity and respect to the uninsured, underinsured, and low-income residents of Hamilton County through professional and dedicated staff and volunteers.
The Society of St. Vincent de Paul offers tangible assistance to those in need on a person-to-person basis. It is this personalized involvement that makes the work of the Society unique. This aid may take the form of intervention, consultation, or often through direct dollar or in-kind service. An essential precept of the Society's work is to provide help while conscientiously maintaining the confidentiality and dignity of those served.
CRS's mission is to assist impoverished and disadvantaged people overseas, working in the spirit of Catholic social teaching to promote the sacredness of human life and the dignity of the human person. Although its mission is rooted in the Catholic faith, its operations serve people based solely on need, regardless of race, religion or ethnicity.
Women's Care Center
Women's Care Center provides free, confidential counseling, support and education to women facing unplanned pregnancies. It serves 26,000 women annually from 28 centers in ten states, including Florida, Illinois, Indiana, Kentucky, Maryland, Michigan, Minnesota, Ohio, Pennsylvania, and Wisconsin.
The O'Connor House
The O'Connor House Mission is to provide a Christian home to help single, pregnant, homeless women improve life for themselves and their children.
Wheeler Mission
Wheeler Mission Ministries helps the homeless in Indiana. Wheeler is a non-denominational, Christian social services organization that provides critically needed goods and services to the homeless, poor, and needy of central Indiana without regard to race, color, sexual orientation, creed, national origin, or religion.
Samaritan's Feet International
Performance Services has partnered with Samaritan's Feet to provide new shoes to toddlers and school children in need in Indiana and Haiti. Our recent projects include LaFosse and an earlier project at Fort Wayne Community Schools (FWCS). Photos of the FWCS event are posted on our Facebook page. You can read more about the work of Samaritan's Feet and Manny Ohonme's mission to furnish a million pairs of shoes to children in need around the world.
REJECT Film
Discovered at the 2013 Heartland Film Festival in Indianapolis, Performance Services is working to help spread the word to K-12 school customers and education associations to bring this film to their schools. At the essence of the film is the idea that social rejection has a profound impact on human life. We share the belief with the movie producer and director, Ruth Thomas-Suh, that REJECT has come at a time when there is an urgent need in our society to share this message with school communities. Supporting this endeavor is a natural extension of our core value proposition of creating and supporting optimal learning environments.
Haiti Mission Trip 2017


text:
Ambrosia — американская поп-арт-рок группа, образованная в 1970 году в Лос-Анджелесе. В первый состав вошли: гитарист и вокалист Дэвид Пек (), бас-гитарист и вокалист Джо Пуэрта (), клавишник Кристофер Норт () и ударник Берли Драммонд (). В период с 1975 по 2005 годы записали десять хитовых песен, входивших в Топ 100 журнала Billboard в разных категориях. Самые известные из них: «How Much I Feel», «Biggest Part of Me» и «You're the Only Woman (You & I)».

Состав

Текущий состав
 Джо Пуэрта — бас-гитара, вокал (1970—1982, 1989 — наши дни)
 Берли Драммонд — ударные, вокал, перкуссия (1970—1982, 1989 — наши дни)
 Кристофер Норт — клавишные, бэк-вокал (1970—1977, 1978—1982, 1989 — наши дни)
 Дуг Джексон — гитара, бэк-вокал (2000 — наши дни)
 Кен Стейси — вокал, перкуссия, гитара (2005—2009, 2014 — наши дни)
 Мэри Харрис — клавишные, бэк-вокал (2012 — наши дни)

Бывшие участники
 Дэвид Пек — гитара, вокал, клавишные (1970—1982, 1989—2000)
 Рик Коулинг — вокал, клавишные, гитара (2010—2013)
 Дэвид С. Льюис — клавишные (1978—1982)
 Ройс Джонс — вокал, перкуссия (1978—1982)
 Брюс Хорнсби — клавишные, бэк-вокал (1982)
 Клифф Вулли — гитара (1980)
 Толлэк Олиестад — вокал, клавишные, губная гармоника (1989—2004)
 Шем Вон Шроек — вокал, перкуссия, гитара, бас-гитара (1989—2003)
 Роберт Берри — вокал, гитара (2004—2005)
 Корнелиус Бампус — саксофон (1980)

Дискография

Синглы
 Holdin' On To Yesterday — 1975 (#17 в США)
 Nice, Nice, Very Nice — 1975 (#63 в США)
 Magical Mystery Tour — 1976 (#39 в США)
 Can't Let A Woman — 1976 (#102 в США)
 Runnin' Away — 1976
 How Much I Feel — 1978 (#3 в США, #30 в Австралии)
 Life Beyond L.A. — 1978
 If Heaven Could Find Me — 1978 (#107 в США)
 Biggest Part of Me — 1980 (#3 в США)
 You're the Only Woman (You & I) — 1980 (#5 в США)
 No Big Deal — 1980 (#105 в США)
 Outside — 1981 (#102 в США)
 Feelin' Alive Again — 1982
 How Can You Love Me — 1982 (#86 в США)
 For Openers (Welcome Home) — 1982 (#44 в США)
 I Just Can't Let Go — 1997 (#26 в США)
 Biggest Part of Me (Remix) — 2004 (#31 в США)

Студийные альбомы
 Ambrosia — 1975 (#22 в США)
 Somewhere I've Never Travelled — 1976 (#79 в США)
 Life Beyond L.A. — 1978 (#19 в США)
 One Eighty — 1980 (#25 в США)
 Road Island — 1982 (#115 в США)

Концертные альбомы
 Live at The Galaxy — 2002
 The Biggest Part of Me: Greatest Hits Live — 2010

Сборники
 Anthology — 1997
 The Essentials — 2002
 How Much I Feel and Other Hits — 2003
 Standing Room Only — 2007

David Pack — сольные альбомы
 Anywhere You Go — 1985
 Unborn — 2004
 The Secret of Movin' On — 2005
 Napa Crossroads — 2014

Примечания

Ссылки
 Официальный сайт
 Ambrosia на Progarchives

Рок-группы из Калифорнии
Музыкальные коллективы, появившиеся в 1970 году
Исполнители Warner Bros. Records
Софт-рок-группы США

redpajama_set_name: RedPajamaWikipedia


text:
Q: Flutter show blank app after set in background Flutter app in ipa from store show blank page after set in background for awhile no design or text appear but if click show navigate to pages but with no design/text
Link for images
https://drive.google.com/folderview?id=1tEOnM2-To43H_qDA2hjnBMoiQzQz3IL-

redpajama_set_name: RedPajamaStackExchange


Creating Inclusive Cultures is the forum for businesses who want to create thriving workplaces for all, working together and learning from each other. The forums focus on key issues, city by city, ensuring that regional insights and knowledge are part of the solution.
The forums are thriving in Leeds, Manchester, Birmingham and Liverpool. Throughout 2019 we will announce other cities that are joining the business forum focused on creating more inclusive cultures.
Creating Inclusive Cultures works with their partners to respond to what businesses and organisations need to drive change and engage employees at all levels.
As the leading recruiting experts in qualified, professional and skilled people, people sit at the heart of our business, both in the people who we employ and also the services that we offer. Hays is proud to be a founding member of CIC. We are confident that CIC will play a key role in enabling organisations to realise the many benefits of having a truly diverse workforce. We are delighted to have the opportunity to bring our expertise to this programme and also actively share its recommendations with our many clients in the Yorkshire regions.
The Bright Horizons community is a vibrant tapestry made of children, families, and employees who represent many different cultures, backgrounds, and experiences. We strive to create a culture that values and includes every individual and celebrates unique differences. Our commitment to diversity is fundamental to supporting the success of our company, so that we may understand and respond to the challenges of our clients, the needs of the families whom we serve, and the evolving goals of our employees. As leaders in our field our partnership with Creating Inclusive Cultures is part of our ongoing intent to provide environments which are fully inclusive and where everyone feels they are in 'the right place'.
Diversity and inclusion has always been important part of our ethos and values, but over the last couple of years we have been actively engaged in raising even more awareness across our organisation about the importance of a diverse workplace. We recognise the direct correlation it can have on creativity, innovation and collaboration, which not only creates a dynamic working environment, but can also drive real benefits for our customers. As a business that has a strong presence in the Leeds area, we are delighted and proud to be part of such an important initiative as a founding member of the CIC. We look forward to sharing our ideas and expertise to drive the diversity and inclusion agenda even further within the region.
Mercer is passionate about creating an inclusive workplace. We all live in diverse communities and are committed to realising the benefits of diversity and inclusion at Mercer. Mercer became involved in Creative Inclusive Cultures to collaborate with a range of other employers on best practice around diversity and inclusion. We are committed to changing our culture and embracing diversity. This will allow us to better support all employees to progress their careers. It will also allow us to attract a range of highly talented employees who are vital to meeting and exceeding our business objectives.


text:
'''
Module of all the controllers used in M-LOOP. The controllers, as the name suggests, control the interface to the experiment and all the learners employed to find optimal parameters.
'''
from __future__ import absolute_import, division, print_function
__metaclass__ = type

import os
import datetime
from importlib import import_module
import logging
import traceback

import numpy as np

from mloop import __version__
import mloop.utilities as mlu
import mloop.learners as mll
import mloop.interfaces as mli

default_controller_archive_filename = 'controller_archive'
default_controller_archive_file_type = 'txt'

class ControllerInterrupt(Exception):
    '''
    Exception that is raised when the controlled is ended with the end flag or event.
    '''
    def __init__(self):
        super(ControllerInterrupt,self).__init__()

def create_controller(interface,
                      controller_type='gaussian_process',
                      **controller_config_dict):
    '''
    Start the controller with the options provided.
    Args:
        interface (interface): Interface with queues and events to be passed to controller
    Keyword Args:
        controller_type (Optional [str]): Defines the type of controller can be 'random', 'nelder', 'gaussian_process' or 'neural_net'. Alternatively, the controller can belong to an external module, in which case this parameter should be 'module_name:controller_name'. Defaults to 'gaussian_process'.
        **controller_config_dict : Options to be passed to controller.
    Returns:
        Controller : threadable object which must be started with start() to get the controller running.
    Raises:
        ValueError : if controller_type is an unrecognized string
    '''
    log = logging.getLogger(__name__)

    controller_type = str(controller_type)
    if controller_type=='gaussian_process':
        controller = GaussianProcessController(interface, **controller_config_dict)
    elif controller_type=='neural_net':
        controller = NeuralNetController(interface, **controller_config_dict)
    elif controller_type=='differential_evolution':
        controller = DifferentialEvolutionController(interface, **controller_config_dict)
    elif controller_type=='nelder_mead':
        controller = NelderMeadController(interface, **controller_config_dict)
    elif controller_type=='random':
        controller = RandomController(interface, **controller_config_dict)
    else:
        # If `controller_type` doesn't match any of the built-in controllers,
        # looks for an external controller with matching name.
        # The `controller_type` should be "module_name:controller_name".
        parts = controller_type.split(":")
        if (len(parts)==2) and all([len(part)>0 for part in parts]):
            try:
                module = import_module(parts[0])
                constructor = getattr(module, parts[1])
            except ModuleNotFoundError:
                log.error(f"Unknown module: {parts[0]}")
                raise ValueError
            except AttributeError:
                log.error(f"Unknown controller type: {parts[0]}.{parts[1]}")
                raise ValueError
            except:
                log.error('Unknown controller type:' + repr(controller_type))
                raise ValueError
            controller = constructor(interface, **controller_config_dict)
        else:
            log.error('Unknown controller type:' + repr(controller_type))
            raise ValueError

    return controller

class Controller():
    '''
    Abstract class for controllers.

    The controller controls the entire M-LOOP process. The controllers for each
    algorithm all inherit from this class. The class stores a variety of data
    which all algorithms use and also includes all of the archiving and saving
    features.

    In order to implement your own controller class the minimum requirement is
    to add a learner to the learner variable and implement the
    `next_parameters()` method where you provide the appropriate information to
    the learner and get the next parameters. See the `RandomController` for a
    simple implementation of a controller. Note the first three keywords are all
    possible halting conditions for the controller. If any of them are satisfied
    the controller will halt (meaning an OR condition is used). This base class
    also creates an empty attribute `self.learner`. The simplest way to make a
    working controller is to assign a learner of some kind to this variable, and
    add appropriate queues and events from it.

    Args:
        interface (interface): The interface process. It is run by the
            controller.

    Keyword Args:
        max_num_runs (Optional [float]): The number of runs before the
            controller stops. If set to `float('+inf')` the controller will run
            forever assuming no other halting conditions are met. Default
            `float('+inf')`, meaning the controller will run until another
            halting condition is met.
        target_cost (Optional [float]): The target cost for the run. If a run
            achieves a cost lower than the target, the controller is stopped.
            Default `float('-inf')`, meaning the controller will run until
            another halting condition is met.
        max_num_runs_without_better_params (Optional [float]): The optimization
            will halt if the number of consecutive runs without improving over
            the best measured value thus far exceeds this number. Default
            `float('+inf')`, meaning the controller will run until another
            halting condition is met.
        max_duration (Optional [float]): The maximum duration of the
            optimization, in seconds of wall time. The actual duration may
            exceed this value slightly, but no new iterations will start after
            `max_duration` seconds have elapsed since `start_datetime`. Default
            is `float('+inf')`, meaning the controller will run until another
            halting condition is met.
        controller_archive_filename (Optional [string]): Filename for archive.
            The archive contains costs, parameter history and other details
            depending on the controller type. Default
            `'controller_archive'`.
        controller_archive_file_type (Optional [string]): File type for archive.
            Can be either `'txt'` for a human readable text file, `'pkl'` for a
            python pickle file, `'mat'` for a matlab file, or `None` to forgo
            saving a controller archive. Default `'txt'`.
        archive_extra_dict (Optional [dict]): A dictionary with any extra
            variables that are to be saved to the archive. If `None`, nothing is
            added. Default `None`.
        start_datetime (Optional datetime): Datetime for when the controller was
            started.

    Attributes:
        params_out_queue (queue): Queue for parameters to next be run by the
            experiment.
        costs_in_queue (queue): Queue for costs (and other details) that have
            been returned by experiment.
        interface_error_queue (queue): Queue for returning errors encountered by
            the interface.
        end_interface (event): Event used to trigger the end of the interface.
        learner (None): The placeholder for the learner. Creating this variable
            is the minimum requirement to make a working controller class.
        learner_params_queue (queue): The parameters queue for the learner.
        learner_costs_queue (queue): The costs queue for the learner.
        end_learner (event): Event used to trigger the end of the learner.
        num_in_costs (int): Counter for the number of costs received.
        num_out_params (int): Counter for the number of parameters received.
        out_params (list): List of all parameters sent out by controller.
        out_extras (list): Any extras associated with the output parameters.
        in_costs (list): List of costs received by controller.
        in_uncers (list): List of uncertainties received by controller.
        best_cost (float): The lowest, and best, cost received by the learner.
        best_uncer (float): The uncertainty associated with the best cost.
        best_params (array): The best parameters received by the learner.
        best_index (float): The run number that produced the best cost.
    '''

    def __init__(
        self,
        interface,
        max_num_runs=float('+inf'),
        target_cost=float('-inf'),
        max_num_runs_without_better_params=float('+inf'),
        max_duration=float('+inf'),
        controller_archive_filename=default_controller_archive_filename,
        controller_archive_file_type=default_controller_archive_file_type,
        archive_extra_dict = None,
        start_datetime = None,
        **kwargs,
    ):

        # Make the logger.
        self.remaining_kwargs = mlu._config_logger(start_datetime=start_datetime, **kwargs)
        self.log = logging.getLogger(__name__)

        # Variables that are included in the controller archive.
        self.num_in_costs = 0
        self.num_out_params = 0
        self.out_params = []
        self.out_type = []
        self.out_extras = []
        self.in_costs = []
        self.in_uncers = []
        self.in_bads = []
        self.in_extras = []
        self.best_cost = float('inf')
        self.best_uncer = float('nan')
        self.best_index = float('nan')
        self.best_params = float('nan')

        # Variables that are used internally.
        self.last_out_params = None
        self.curr_params = None
        self.curr_cost = None
        self.curr_uncer = None
        self.curr_bad = None
        self.curr_extras = None
        self.num_last_best_cost = 0
        self.halt_reasons = []

        # Constants.
        self.controller_wait = float(1)

        # Learner-related variables.
        self.learner_params_queue = None
        self.learner_costs_queue = None
        self.end_learner = None
        self.learner = None

        # Variables set by user.

        # Store the interface and extract important attributes from it.
        if isinstance(interface, mli.Interface):
            self.interface = interface
        else:
            self.log.error('interface is not a Interface as defined in the M-LOOP package.')
            raise TypeError

        self.params_out_queue = interface.params_out_queue
        self.costs_in_queue = interface.costs_in_queue
        self.interface_error_queue = interface.interface_error_queue
        self.end_interface = interface.end_event

        # Halting options.
        self.max_num_runs = float(max_num_runs)
        if self.max_num_runs <= 0:
            msg = f"max_num_runs must be greater than zero but was {max_num_runs}."
            self.log.error(msg)
            raise ValueError(msg)
        self.target_cost = float(target_cost)
        self.max_num_runs_without_better_params = float(max_num_runs_without_better_params)
        if self.max_num_runs_without_better_params <= 0:
            msg = f"max_num_runs_without_better_params must be greater than zero but was {max_num_runs_without_better_params}."
            self.log.error(msg)
            raise ValueError(msg)
        self.max_duration = float(max_duration)
        if self.max_duration <= 0:
            msg = f"max_duration must be greater than zero but was {max_duration}."
            self.log.error(msg)
            raise ValueError(msg)

        # Other options.
        if start_datetime is None:
            start_datetime = datetime.datetime.now()
        if isinstance(start_datetime, datetime.datetime):
            self.start_datetime = start_datetime
        else:
            msg = (
                "start_datetime must be of type datetime.datetime but was "
                f"{start_datetime} (type: {type(start_datetime)})."
            )
            self.log.error(msg)
            raise ValueError(msg)

        if mlu.check_file_type_supported(controller_archive_file_type):
            self.controller_archive_file_type = controller_archive_file_type
        else:
            self.log.error('File in type is not supported:' + repr(controller_archive_file_type))
            raise ValueError
        if controller_archive_filename is None:
            self.controller_archive_filename = None
        else:
            # Store self.controller_archive_filename without any path, but
            # include any path components in controller_archive_filename when
            # constructing the full path.
            controller_archive_filename = str(controller_archive_filename)
            self.controller_archive_filename = os.path.basename(controller_archive_filename)
            filename_suffix = mlu.generate_filename_suffix(
                self.controller_archive_file_type,
                file_datetime=self.start_datetime,
            )
            filename = controller_archive_filename + filename_suffix
            self.total_archive_filename = os.path.join(mlu.archive_foldername, filename)

            # Include any path info from controller_archive_filename when
            # creating directory for archive files.]
            archive_dir = os.path.dirname(self.total_archive_filename)
            if not os.path.exists(archive_dir):
                os.makedirs(archive_dir)

        self.archive_dict = {'mloop_version':__version__,
                             'archive_type':'controller',
                             'num_out_params':self.num_out_params,
                             'out_params':self.out_params,
                             'out_type':self.out_type,
                             'out_extras':self.out_extras,
                             'in_costs':self.in_costs,
                             'in_uncers':self.in_uncers,
                             'in_bads':self.in_bads,
                             'in_extras':self.in_extras,
                             'max_num_runs':self.max_num_runs,
                             'start_datetime':mlu.datetime_to_string(self.start_datetime)}

        if archive_extra_dict is not None:
            self.archive_dict.update(archive_extra_dict)

        self.log.debug('Controller init completed.')

    def check_end_conditions(self):
        '''
        Check whether any of the end contions have been met.

        In particular this method check for any of the following conditions:

        * If the number of iterations has reached `max_num_runs`.
        * If the `target_cost` has been reached.
        * If `max_num_runs_without_better_params` iterations in a row have
          occurred without any improvement.
        * If `max_duration` seconds or more has elapsed since `start_datetime`.

        Returns:
            bool: `True`, if the controller should continue or `False` if one or
                more halting conditions have been met and the controller should
                end.
        '''
        # Determine how long it has been since self.start_datetime.
        duration = datetime.datetime.now() - self.start_datetime
        duration = duration.total_seconds()  # Convert to seconds.

        # Check all of the halting conditions. Many if statements are used
        # instead of elif blocks so that we can mark if the optimization halted
        # for more than one reason.
        if self.num_in_costs >= self.max_num_runs:
            self.halt_reasons.append('Maximum number of runs reached.')
        if self.best_cost <= self.target_cost:
            self.halt_reasons.append('Target cost reached.')
        if self.num_last_best_cost >= self.max_num_runs_without_better_params:
            self.halt_reasons.append(
                'Maximum number of runs without better params reached.'
            )
        if duration > self.max_duration:
            self.halt_reasons.append('Maximum duration reached.')

        # The optimization should only continue if self.halt_reasons is empty.
        return not bool(self.halt_reasons)

    def _update_controller_with_learner_attributes(self):
        '''
        Update the controller with properties from the learner.
        '''
        self.learner_params_queue = self.learner.params_out_queue
        self.learner_costs_queue = self.learner.costs_in_queue
        self.end_learner = self.learner.end_event
        self.remaining_kwargs = self.learner.remaining_kwargs
        self.num_params = self.learner.num_params
        self.min_boundary = self.learner.min_boundary
        self.max_boundary = self.learner.max_boundary
        self.param_names = self.learner.param_names

        self.archive_dict.update(
            {
                'num_params': self.num_params,
                'min_boundary': self.min_boundary,
                'max_boundary': self.max_boundary,
                'param_names': self.param_names,
            }
        )

    def _put_params_and_out_dict(self, params, param_type=None, **kwargs):
        '''
        Send parameters to queue with optional additional keyword arguments.

        This method also saves sent variables in appropriate storage arrays.

        Args:
            params (array): Array of values to be experimentally tested.
            param_type (Optional, str): The learner type which generated the
                parameter values. Because some learners use other learners as
                trainers, the parameter type can be different for different
                iterations during a given optimization. This value will be
                stored in `self.out_type` and in the `out_type` list in the
                controller archive. If `None`, then it will be set to
                `self.learner.OUT_TYPE`. Default `None`.
        Keyword Args:
            **kwargs: Any additional keyword arguments will be stored in
                `self.out_extras` and in the `out_extras` list in the controller
                archive.
        '''
        # Set default values if needed.
        if param_type is None:
            param_type = self.learner.OUT_TYPE

        # Do one last check to ensure parameter values are within the allowed
        # limits before sending those values to the interface.
        params = self._enforce_boundaries(params)

        # Send the parameters to the interface and update various attributes.
        out_dict = {'params':params}
        out_dict.update(kwargs)
        self.params_out_queue.put(out_dict)
        self.num_out_params += 1
        self.last_out_params = params
        self.out_params.append(params)
        self.out_extras.append(kwargs)
        self.out_type.append(param_type)
        self.log.info('params ' + str(params))
        #self.log.debug('Put params num:' + repr(self.num_out_params ))

    def _enforce_boundaries(self, params):
        '''
        Enforce the minimum and maximum parameter boundaries.

        If the values in params extend outside of the allowed boundaries set by
        `self.min_boundary` and `self.max_boundary` by a nontrivial amount, then
        this method will raise an `RuntimeError`.

        To avoid numerical precision problems, this method actually gently clips
        values which barely exceed the boundaries. This is because variables are
        internally scaled and thus may very slightly violate the boundaries
        after being unscaled. If a parameter's value only slightly exceeds the
        boundaries, then its value will be set equal to the boundary. If a value
        exceeds the boundary by a nontrivial amount, then a `RuntimeError` will
        be raised.

        Note that although this method is forgiving about input parameter values
        very slightly exceeding the boundaries, it is completely strict about
        returning parameter values which obey the boundaries. Thus it is safe to
        assume that the returned values are within the range set by
        `self.min_boundary` and `self.max_boundary` (inclusively).

        Args:
            params (array): Array of values to be experimentally tested.

        Raises:
            RuntimeError: A `RuntimeError` is raised if any value in `params`
                exceeds the parameter value boundaries by a nontrivial amount.

        Returns:
            array: The input `params`, except that any values which slightly
                exceed the boundaries will have been clipped to stay within the
                boundaries exactly.
        '''
        # Check for any values barely below the minimum boundary.
        is_below = (params < self.min_boundary)
        is_close = np.isclose(params, self.min_boundary)
        barely_below = np.logical_and(is_below, is_close)
        # The line below leaves most params entries untouched. It just takes the
        # ones which are barely below the boundary and moves them up to the
        # minimum boundary.
        params = np.where(barely_below, self.min_boundary, params)

        # Perform a similar procedure for the maximum boundary.
        is_above = (params > self.max_boundary)
        is_close = np.isclose(params, self.max_boundary)
        barely_above = np.logical_and(is_above, is_close)
        params = np.where(barely_above, self.max_boundary, params)

        # Ensure that all values are within the boundaries now. If a parameter
        # was well outside the boundaries then the above should not have changed
        # its value and the checks below will be violated.
        if not np.all(params >= self.min_boundary):
            msg = (
                f"Minimum boundary violated. Parameter values are {params}, "
                f"minimum bounday is {self.min_boundary}, and "
                f"(params - boundary) is {params - self.min_boundary}."
            )
            self.log.error(msg)
            raise RuntimeError(msg)
        if not np.all(params <= self.max_boundary):
            msg = (
                f"Maximum boundary violated. Parameter values are {params}, "
                f"maximum bounday is {self.min_boundary}, and "
                f"(boundary - params) is {self.max_boundary - params})."
            )
            self.log.error(msg)
            raise RuntimeError(msg)

        return params

    def _get_cost_and_in_dict(self):
        '''
        Get cost, uncertainty, parameters, bad and extra data from experiment.

        This method stores results in lists and also puts data in the
        appropriate 'current' variables. This method doesn't return anything and
        instead stores all of its results in the internal storage arrays and the
        'current' variables.

        If the interface encounters an error, it will pass the error to the
        controller here so that the error can be re-raised in the controller's
        thread (note that the interface runs in a separate thread).
        '''
        while True:
            try:
                in_dict = self.costs_in_queue.get(True, self.controller_wait)
            except mlu.empty_exception:
                # Check for an error from the interface.
                try:
                    err = self.interface_error_queue.get_nowait()
                except mlu.empty_exception:
                    # The interface didn't send an error, so go back to waiting
                    # for results.
                    continue
                else:
                    # Log and re-raise the error sent by the interface.
                    msg = 'The interface raised an error with traceback:\n'
                    msg = msg + '\n'.join(
                        traceback.format_tb(err.__traceback__),
                    )
                    self.log.error(msg)
                    raise err
            else:
                # Got a cost dict, so exit this while loop.
                break

        self.num_in_costs += 1
        self.num_last_best_cost += 1

        if not ('cost' in in_dict) and (not ('bad' in in_dict) or not in_dict['bad']):
            self.log.error('You must provide at least the key cost or the key bad with True.')
            raise ValueError
        try:
            self.curr_cost = float(in_dict.pop('cost',float('nan')))
            self.curr_uncer = float(in_dict.pop('uncer',0))
            self.curr_bad = bool(in_dict.pop('bad',False))
            self.curr_extras = in_dict
        except ValueError:
            self.log.error('One of the values you provided in the cost dict could not be converted into the right type.')
            raise
        if self.curr_bad and ('cost' in in_dict):
            self.log.warning('The cost provided with the bad run will be saved, but not used by the learners.')

        self.in_costs.append(self.curr_cost)
        self.in_uncers.append(self.curr_uncer)
        self.in_bads.append(self.curr_bad)
        self.in_extras.append(self.curr_extras)
        self.curr_params = self.last_out_params
        if self.curr_cost < self.best_cost:
            self.best_cost = self.curr_cost
            self.best_uncer = self.curr_uncer
            self.best_index =  self.num_in_costs
            self.best_params = self.curr_params
            self.num_last_best_cost = 0
        if self.curr_bad:
            self.log.info('bad run')
        else:
            self.log.info('cost ' + str(self.curr_cost) + ' +/- ' + str(self.curr_uncer))
        #self.log.debug('Got cost num:' + repr(self.num_in_costs))

    def save_archive(self):
        '''
        Save the archive associated with the controller class. Only occurs if the filename for the archive is not None. Saves with the format previously set.
        '''
        if self.controller_archive_filename is not None:
            self.archive_dict.update({'num_in_costs':self.num_in_costs,
                                      'num_out_params':self.num_out_params,
                                      'best_cost':self.best_cost,
                                      'best_uncer':self.best_uncer,
                                      'best_params':self.best_params,
                                      'best_index':self.best_index})
            try:
                mlu.save_dict_to_file(self.archive_dict,self.total_archive_filename,self.controller_archive_file_type)
            except ValueError:
                self.log.error('Attempted to save with unknown archive file type, or some other value error.')
                raise
        else:
            self.log.debug('Did not save controller archive file.')

    def optimize(self):
        '''
        Optimize the experiment. This code learner and interface processes/threads are launched and appropriately ended.
        Starts both threads and catches kill signals and shuts down appropriately.
        '''
        log = logging.getLogger(__name__)

        try:
            log.info('Optimization started.')
            self._start_up()
            self._optimization_routine()
            log.info('Controller finished. Closing down M-LOOP. Please wait a moment...')
        except ControllerInterrupt:
            self.log.warning('Controller ended by interruption.')
        except (KeyboardInterrupt,SystemExit):
            log.warning('!!! Do not give the interrupt signal again !!! \n M-LOOP stopped with keyboard interupt or system exit. Please wait at least 1 minute for the threads to safely shut down. \n ')
            log.warning('Closing down controller.')
        except Exception:
            self.log.warning('Controller ended due to exception of some kind. Starting shut down...')
            self.halt_reasons.append('Error occurred.')
            self._shut_down()
            self.log.warning('Safely shut down. Below are results found before exception.')
            self.print_results()
            raise
        self._shut_down()
        self.print_results()
        self.log.info('M-LOOP Done.')

    def _start_up(self):
        '''
        Start the learner and interface threads/processes.
        '''
        self.learner.start()
        self.interface.start()

    def _shut_down(self):
        '''
        Shutdown and clean up resources of the controller. end the learners, queue_listener and make one last save of archive.
        '''
        self.log.debug('Learner end event set.')
        self.end_learner.set()
        self.log.debug('Interface end event set.')
        self.end_interface.set()
        #After 3 or 4 executions of mloop in same python environment, sometimes execution can be trapped here
        #Likely to be a bug with multiprocessing in python, but difficult to isolate.
        #current solution is to join with a timeout and kill if that fails
        self.learner.join()
        self.log.debug('Learner joined.')
        self.interface.join()
        self.log.debug('Interface joined.')
        self.save_archive()

    def print_results(self):
        '''
        Print results from optimization run to the logs
        '''
        self.log.info('Optimization ended because:')
        for reason in self.halt_reasons:
            self.log.info('\t* ' + reason)
        self.log.info('Results:')
        self.log.info('\t* Best parameters found:' + str(self.best_params))
        self.log.info('\t* Best cost returned:' + str(self.best_cost) + ' +/- ' + str(self.best_uncer))
        self.log.info('\t* Best run number:' + str(self.best_index))

    def _optimization_routine(self):
        '''
        Runs controller main loop. Gives parameters to experiment and saves costs returned.
        '''
        self.log.debug('Start controller loop.')
        self.log.info('Run:' + str(self.num_in_costs +1))
        next_params = self._first_params()
        self._put_params_and_out_dict(
            next_params,
            param_type=self.learner.OUT_TYPE,
        )
        self.save_archive()
        self._get_cost_and_in_dict()
        while self.check_end_conditions():
            self.log.info('Run:' + str(self.num_in_costs +1))
            next_params = self._next_params()
            self._put_params_and_out_dict(
                next_params,
                param_type=self.learner.OUT_TYPE,
            )
            self.save_archive()
            self._get_cost_and_in_dict()
        self.log.debug('End controller loop.')
        # Send result of last run to learner to make sure that it makes it to
        # the learner archive.
        self._send_to_learner()

    def _first_params(self):
        '''
        Checks queue to get the first parameters.

        Returns:
            Parameters for first experiment
        '''
        return self.learner_params_queue.get()

    def _send_to_learner(self):
        '''
        Send the latest cost info the the learner.
        '''
        if self.curr_bad:
            cost = float('inf')
        else:
            cost = self.curr_cost
        message = (
            self.curr_params,
            cost,
            self.curr_uncer,
            self.curr_bad,
        )
        self.learner_costs_queue.put(message)

    def _next_params(self):
        '''
        Send latest cost info and get next parameters from the learner.
        '''
        self._send_to_learner()
        return self.learner_params_queue.get()

class RandomController(Controller):
    '''
    Controller that simply returns random variables for the next parameters. Costs are stored but do not influence future points picked.
    Args:
        params_out_queue (queue): Queue for parameters to next be run by experiment.
        costs_in_queue (queue): Queue for costs (and other details) that have been returned by experiment.
        **kwargs (Optional [dict]): Dictionary of options to be passed to Controller and Random Learner.
    '''
    def __init__(self, interface,**kwargs):

        super(RandomController,self).__init__(interface, **kwargs)
        self.learner = mll.RandomLearner(start_datetime = self.start_datetime,
                                         **self.remaining_kwargs)

        self._update_controller_with_learner_attributes()

        self.log.debug('Random controller init completed.')

class NelderMeadController(Controller):
    '''
    Controller for the Nelder–Mead solver. Suggests new parameters based on the Nelder–Mead algorithm. Can take no boundaries or hard boundaries. More details for the Nelder–Mead options are in the learners section.
    Args:
        params_out_queue (queue): Queue for parameters to next be run by experiment.
        costs_in_queue (queue): Queue for costs (and other details) that have been returned by experiment.
        **kwargs (Optional [dict]): Dictionary of options to be passed to Controller parent class and Nelder–Mead learner.
    '''
    def __init__(self, interface,
                **kwargs):
        super(NelderMeadController,self).__init__(interface, **kwargs)

        self.learner = mll.NelderMeadLearner(start_datetime = self.start_datetime,
                                             **self.remaining_kwargs)

        self._update_controller_with_learner_attributes()

class DifferentialEvolutionController(Controller):
    '''
    Controller for the differential evolution learner.
    Args:
        params_out_queue (queue): Queue for parameters to next be run by experiment.
        costs_in_queue (queue): Queue for costs (and other details) that have been returned by experiment.
        **kwargs (Optional [dict]): Dictionary of options to be passed to Controller parent class and differential evolution learner.
    '''
    def __init__(self, interface,
                **kwargs):
        super(DifferentialEvolutionController,self).__init__(interface, **kwargs)

        self.learner = mll.DifferentialEvolutionLearner(start_datetime = self.start_datetime,
                                                        **self.remaining_kwargs)

        self._update_controller_with_learner_attributes()

class MachineLearnerController(Controller):
    '''
    Abstract Controller class for the machine learning based solvers.
    Args:
        interface (Interface): The interface to the experiment under optimization.
        **kwargs (Optional [dict]): Dictionary of options to be passed to Controller parent class and initial training learner.
    Keyword Args:
        training_type (Optional [string]): The type for the initial training source can be 'random' for the random learner, 'nelder_mead' for the Nelder–Mead learner or 'differential_evolution' for the Differential Evolution learner. This learner is also called if the machine learning learner is too slow and a new point is needed. Default 'differential_evolution'.
        num_training_runs (Optional [int]): The number of training runs to before starting the learner. If None, will be ten or double the number of parameters, whatever is larger.
        no_delay (Optional [bool]): If True, there is never any delay between a returned cost and the next parameters to run for the experiment. In practice, this means if the machine learning learner has not prepared the next parameters in time the learner defined by the initial training source is used instead. If false, the controller will wait for the machine learning learner to predict the next parameters and there may be a delay between runs.
    '''

    def __init__(self, interface,
                 training_type='differential_evolution',
                 num_training_runs=None,
                 no_delay=True,
                 num_params=None,
                 min_boundary=None,
                 max_boundary=None,
                 trust_region=None,
                 learner_archive_filename = mll.default_learner_archive_filename,
                 learner_archive_file_type = mll.default_learner_archive_file_type,
                 param_names=None,
                 **kwargs):

        super(MachineLearnerController,self).__init__(interface, **kwargs)

        if num_training_runs is None:
            if num_params is None:
                self.num_training_runs = 10
            else:
                self.num_training_runs = max(10, 2*int(num_params))
        else:
            self.num_training_runs = int(num_training_runs)
        if self.num_training_runs<=0:
            self.log.error('Number of training runs must be larger than zero:'+repr(self.num_training_runs))
            raise ValueError
        self.no_delay = bool(no_delay)

        self.training_type = str(training_type)
        if self.training_type == 'random':
            self.learner = mll.RandomLearner(start_datetime=self.start_datetime,
                                             num_params=num_params,
                                             min_boundary=min_boundary,
                                             max_boundary=max_boundary,
                                             trust_region=trust_region,
                                             learner_archive_filename=None,
                                             learner_archive_file_type=learner_archive_file_type,
                                             param_names=param_names,
                                             **self.remaining_kwargs)

        elif self.training_type == 'nelder_mead':
            self.learner = mll.NelderMeadLearner(start_datetime=self.start_datetime,
                                                 num_params=num_params,
                                                 min_boundary=min_boundary,
                                                 max_boundary=max_boundary,
                                                 learner_archive_filename=None,
                                                 learner_archive_file_type=learner_archive_file_type,
                                                 param_names=param_names,
                                                 **self.remaining_kwargs)

        elif self.training_type == 'differential_evolution':
            self.learner = mll.DifferentialEvolutionLearner(start_datetime=self.start_datetime,
                                                            num_params=num_params,
                                                            min_boundary=min_boundary,
                                                            max_boundary=max_boundary,
                                                            trust_region=trust_region,
                                                            evolution_strategy='rand2',
                                                            learner_archive_filename=None,
                                                            learner_archive_file_type=learner_archive_file_type,
                                                            param_names=param_names,
                                                            **self.remaining_kwargs)

        else:
            self.log.error('Unknown training type provided to machine learning controller:' + repr(training_type))

        self.archive_dict.update({'training_type':self.training_type})
        self._update_controller_with_learner_attributes()

    def _update_controller_with_machine_learner_attributes(self):

        self.ml_learner_params_queue = self.ml_learner.params_out_queue
        self.ml_learner_costs_queue = self.ml_learner.costs_in_queue
        self.end_ml_learner = self.ml_learner.end_event
        self.new_params_event = self.ml_learner.new_params_event
        self.remaining_kwargs = self.ml_learner.remaining_kwargs
        self.generation_num = self.ml_learner.generation_num

    def _get_cost_and_in_dict(self):
        '''
        Get cost, uncertainty, parameters, bad, and extra data from experiment.

        This method calls `_get_cost_and_in_dict()` of the parent `Controller`
        class and additionally sends the results to machine learning learner.
        '''
        super(MachineLearnerController,self)._get_cost_and_in_dict()
        self.ml_learner_costs_queue.put((self.curr_params,
                                         self.curr_cost,
                                         self.curr_uncer,
                                         self.curr_bad))

    def _start_up(self):
        '''
        Runs pararent method and also starts training_learner.
        '''
        super(MachineLearnerController,self)._start_up()
        self.log.debug('ML learner started.')
        self.ml_learner.start()

    def _optimization_routine(self):
        '''
        Overrides _optimization_routine. Uses the parent routine for the training runs. Implements a customized _optimization_routine when running the machine learning learner.
        '''
        #Run the training runs using the standard optimization routine.
        self.log.debug('Starting training optimization.')
        self.log.info('Run:' + str(self.num_in_costs +1) + ' (training)')
        next_params = self._first_params()
        self._put_params_and_out_dict(
            next_params,
            param_type=self.learner.OUT_TYPE,
        )
        self.save_archive()
        self._get_cost_and_in_dict()

        while (self.num_in_costs < self.num_training_runs) and self.check_end_conditions():
            self.log.info('Run:' + str(self.num_in_costs +1) + ' (training)')
            next_params = self._next_params()
            self._put_params_and_out_dict(
                next_params,
                param_type=self.learner.OUT_TYPE,
            )
            self.save_archive()
            self._get_cost_and_in_dict()

        if self.check_end_conditions():
            #Start last training run
            self.log.info('Run:' + str(self.num_in_costs +1) + ' (training)')
            next_params = self._next_params()
            self._put_params_and_out_dict(
                next_params,
                param_type=self.learner.OUT_TYPE,
            )

            self.log.debug('Starting ML optimization.')
            # This may be a race. Although the cost etc. is put in the queue to
            # the learner before the new_params_event is set, it's not clear if
            # python guarantees that the other process will see the item in the
            # queue before the event is set. To work around this,
            # learners.MachineLearner.get_params_and_costs() blocks with a
            # timeout while waiting for an item in the queue.
            self._get_cost_and_in_dict()
            self.save_archive()
            self.new_params_event.set()
            self.log.debug('End training runs.')

            ml_consec = 0
            ml_count = 0

        while self.check_end_conditions():
            run_num = self.num_in_costs + 1
            if ml_consec==self.generation_num or (self.no_delay and self.ml_learner_params_queue.empty()):
                self.log.info('Run:' + str(run_num) + ' (trainer)')
                next_params = self._next_params()
                self._put_params_and_out_dict(
                    next_params,
                    param_type=self.learner.OUT_TYPE,
                )
                ml_consec = 0
            else:
                self.log.info('Run:' + str(run_num) + ' (machine learner)')
                next_params = self.ml_learner_params_queue.get()
                self._put_params_and_out_dict(
                    next_params,
                    param_type=self.ml_learner.OUT_TYPE,
                )
                ml_consec += 1
                ml_count += 1

            self.save_archive()
            self._get_cost_and_in_dict()

            if ml_count==self.generation_num:
                self.new_params_event.set()
                ml_count = 0

    def _shut_down(self):
        '''
        Shutdown and clean up resources of the machine learning controller.
        '''
        self.log.debug('ML learner end set.')
        self.end_ml_learner.set()
        self.ml_learner.join()

        self.log.debug('ML learner joined')
        last_dict = None
        while not self.ml_learner_params_queue.empty():
            last_dict = self.ml_learner_params_queue.get_nowait()
        if isinstance(last_dict, dict):
            try:
                self.predicted_best_parameters = last_dict['predicted_best_parameters']
                self.predicted_best_cost = last_dict['predicted_best_cost']
                self.predicted_best_uncertainty = last_dict['predicted_best_uncertainty']
            except KeyError:
                pass
            try:
                self.number_of_local_minima = last_dict['number_of_local_minima']
                self.local_minima_parameters = last_dict['local_minima_parameters']
                self.local_minima_costs = last_dict['local_minima_costs']
                self.local_minima_uncers = last_dict['local_minima_uncers']
            except KeyError:
                pass
            self.archive_dict.update(last_dict)
        else:
            if self.ml_learner.predict_global_minima_at_end or self.ml_learner.predict_local_minima_at_end:
                self.log.info('Machine learning learner did not provide best and/or all minima.')
        super(MachineLearnerController,self)._shut_down()

    def print_results(self):
        '''
        Adds some additional output to the results specific to controller.
        '''
        super(MachineLearnerController,self).print_results()
        try:
            self.log.info('\t* Predicted best parameters:' + str(self.predicted_best_parameters))
            try:
                errorstring = ' +/- ' + str(self.predicted_best_uncertainty)
            except AttributeError:
                errorstring = ''
            self.log.info('\t* Predicted best cost:' + str(self.predicted_best_cost) + errorstring)
        except AttributeError:
            pass
        try:
            self.log.info('\t* Predicted number of local minima:' + str(self.number_of_local_minima))
        except AttributeError:
            pass

class GaussianProcessController(MachineLearnerController):
    '''
    Controller for the Gaussian Process solver. Primarily suggests new points from the Gaussian Process learner. However, during the initial few runs it must rely on a different optimization algorithm to get some points to seed the learner.
    Args:
        interface (Interface): The interface to the experiment under optimization.
        **kwargs (Optional [dict]): Dictionary of options to be passed to MachineLearnerController parent class and Gaussian Process learner.
    Keyword Args:
    '''

    def __init__(
        self,
        interface,
        num_params=None,
        min_boundary=None,
        max_boundary=None,
        trust_region=None,
        learner_archive_filename = mll.default_learner_archive_filename,
        learner_archive_file_type = mll.default_learner_archive_file_type,
        param_names=None,
        **kwargs,
    ):

        super(GaussianProcessController,self).__init__(
            interface,
            num_params=num_params,
            min_boundary=min_boundary,
            max_boundary=max_boundary,
            trust_region=trust_region,
            learner_archive_filename=learner_archive_filename,
            learner_archive_file_type=learner_archive_file_type,
            param_names=param_names,
            **kwargs,
        )

        self.ml_learner = mll.GaussianProcessLearner(
            start_datetime=self.start_datetime,
            num_params=num_params,
            min_boundary=min_boundary,
            max_boundary=max_boundary,
            trust_region=trust_region,
            learner_archive_filename=learner_archive_filename,
            learner_archive_file_type=learner_archive_file_type,
            param_names=param_names,
            **self.remaining_kwargs,
        )

        self._update_controller_with_machine_learner_attributes()

class NeuralNetController(MachineLearnerController):
    '''
    Controller for the Neural Net solver. Primarily suggests new points from the Neural Net learner. However, during the initial few runs it must rely on a different optimization algorithm to get some points to seed the learner.
    Args:
        interface (Interface): The interface to the experiment under optimization.
        **kwargs (Optional [dict]): Dictionary of options to be passed to MachineLearnerController parent class and Neural Net learner.
    Keyword Args:
    '''

    def __init__(
        self,
        interface,
        num_params=None,
        min_boundary=None,
        max_boundary=None,
        trust_region=None,
        learner_archive_filename = mll.default_learner_archive_filename,
        learner_archive_file_type = mll.default_learner_archive_file_type,
        param_names=None,
        **kwargs,
    ):

        super(NeuralNetController,self).__init__(
            interface,
            num_params=num_params,
            min_boundary=min_boundary,
            max_boundary=max_boundary,
            trust_region=trust_region,
            learner_archive_filename=learner_archive_filename,
            learner_archive_file_type=learner_archive_file_type,
            param_names=param_names,
            **kwargs,
        )

        self.ml_learner = mll.NeuralNetLearner(
            start_datetime=self.start_datetime,
            num_params=num_params,
            min_boundary=min_boundary,
            max_boundary=max_boundary,
            trust_region=trust_region,
            learner_archive_filename=learner_archive_filename,
            learner_archive_file_type=learner_archive_file_type,
            param_names=param_names,
            **self.remaining_kwargs,
        )

        self._update_controller_with_machine_learner_attributes()

redpajama_set_name: RedPajamaGithub