Home Blog Page 6

Cornell College teaches robots new duties from how-to movies in simply half-hour

0


Cornell College teaches robots new duties from how-to movies in simply half-hour

A RHyME-equipped robotic choosing up a mug from a counter. | Supply: Cornell College

Cornell College researchers have developed a brand new robotic framework powered by synthetic intelligence. RHyME — Retrieval for Hybrid Imitation underneath Mismatched Execution — permits robots to study duties by watching a single how-to video.

Robots could be finicky learners, mentioned the Columbia staff. Traditionally, they’ve required exact, step-by-step instructions to finish fundamental duties. In addition they are likely to stop when issues go off-script, like after dropping a device or dropping a screw. Nonetheless, RHyME may fast-track the event and deployment of robotic methods by considerably lowering the time, power, and cash wanted to coach them, the researchers claimed.

“One of many annoying issues about working with robots is accumulating a lot information on the robotic doing totally different duties,” mentioned Kushal Kedia, a doctoral scholar within the discipline of pc science. “That’s not how people do duties. We have a look at different individuals as inspiration.”

Kedia will current the paper, “One-Shot Imitation underneath Mismatched Execution,” subsequent month on the Institute of Electrical and Electronics Engineers’ (IEEE) Worldwide Convention on Robotics and Automation (ICRA) in Atlanta.

Paving the trail for dwelling robots

The college staff mentioned dwelling robotic assistants are nonetheless a good distance off as a result of they lack the wits to navigate the bodily world and its numerous contingencies.

To get robots up to the mark, researchers like Kedia are coaching them with how-to movies — human demonstrations of assorted duties in a lab setting. The Cornell researchers mentioned they hope this strategy, a department of machine studying known as “imitation studying,” will allow robots to study a sequence of duties quicker and have the ability to adapt to real-world environments.

“Our work is like translating French to English – we’re translating any given process from human to robotic,” mentioned senior writer Sanjiban Choudhury, assistant professor of pc science.

This translation process nonetheless faces a broader problem: People transfer too fluidly for a robotic to trace and mimic, and coaching robots requires lots of video. Moreover, video demonstrations of, say, choosing up a serviette or stacking dinner plates have to be carried out slowly and flawlessly. Any mismatch in actions between the video and the robotic has traditionally spelled doom for robotic studying, the researchers mentioned.

“If a human strikes in a approach that’s any totally different from how a robotic strikes, the tactic instantly falls aside,” Choudhury mentioned. “Our pondering was, ‘Can we discover a principled solution to take care of this mismatch between how people and robots do duties?’”

Cornell RHyME helps robots study multi-step duties

RHyME is the staff’s reply – a scalable strategy that makes robots much less finicky and extra adaptive. It allows a robotic system to make use of its personal reminiscence and join the dots when performing duties it has seen solely as soon as by drawing on movies it has seen.

For instance, a RHyME-equipped robotic proven a video of a human fetching a mug from the counter and putting it in a close-by sink will comb its financial institution of movies and draw inspiration from related actions, like greedy a cup and decreasing a utensil.

The staff mentioned RHyME paves the best way for robots to study multiple-step sequences whereas considerably decreasing the quantity of robotic information wanted for coaching. RHyME requires simply half-hour of robotic information; in a lab setting, robots skilled utilizing the system achieved a greater than 50% improve in process success in comparison with earlier strategies, the Cornell researchers mentioned.

“This work is a departure from how robots are programmed right this moment. The established order of programming robots is 1000’s of hours of teleoperation to show the robotic methods to do duties. That’s simply not possible,” Choudhury acknowledged. “With RHyME, we’re shifting away from that and studying to coach robots in a extra scalable approach.”


SITE AD for the 2025 Robotics Summit registration.
Register now so you do not miss out!


How Google’s AI Is Unlocking the Secrets and techniques of Dolphin Communication

0


Dolphins are recognized for his or her intelligence, advanced social behaviors, and complicated communication programs. For years, scientists and animal lovers have been fascinated by the thought of whether or not dolphins possess a language just like that of people. Lately, synthetic intelligence (AI) has opened up thrilling new potentialities for exploring this query. One of the progressive developments on this area is the collaboration between Google and the Wild Dolphin Undertaking (WDP) to create DolphinGemma, an AI mannequin designed to research dolphin vocalizations. This breakthrough couldn’t solely assist decode dolphin communication but additionally probably pave the best way for two-way interactions with these exceptional creatures.

AI’s Position in Understanding Dolphin Sounds

Dolphins talk utilizing a mixture of clicks, whistles, and physique actions. These sounds differ in frequency and depth, which can sign completely different messages relying on the social context, akin to foraging, mating, or interacting with others. Regardless of years of research, understanding the total vary of those indicators has confirmed difficult. Conventional strategies of remark and evaluation battle to deal with the large quantity of knowledge generated by dolphin vocalizations, making it troublesome to attract insights.

AI helps overcome this problem by utilizing machine studying and pure language processing (NLP) algorithms to research giant volumes of dolphin sound information. These fashions can establish patterns and connections in vocalizations which can be past the capabilities of the human ear. AI can differentiate between numerous kinds of dolphin sounds, classify them primarily based on traits, and hyperlink sure sounds to particular behaviors or emotional states. For instance, researchers have observed that sure whistles appear to narrate to social interactions, whereas clicks are sometimes tied to navigation or echolocation.

Whereas AI holds nice potential in decoding dolphin sounds, gathering and processing huge quantities of knowledge from dolphin pods and coaching AI fashions on such a big dataset stay vital challenges. To handle these challenges, Google and the WDP have developed DolphinGemma, an AI mannequin designed particularly for analyzing dolphin communication. The mannequin is skilled on intensive datasets and may detect advanced patterns in dolphin vocalizations.

Understanding DolphinGemma

DolphinGemma is constructed on Google’s Gemma, an open-source generative AI fashions with round 400 million parameters. DolphinGemma is designed to study the construction of dolphin vocalizations and generate new, dolphin-like sound sequences. Developed in collaboration with the WDP and Georgia Tech, the mannequin makes use of a dataset of Atlantic noticed dolphin vocalizations which were collected since 1985. The mannequin makes use of Google’s SoundStream expertise to tokenize these sounds, permitting it to foretell the subsequent sound in a sequence. Very similar to how language fashions generate textual content, DolphinGemma predicts the sounds dolphins may make, which assist it to establish patterns that might signify grammar or syntax in dolphin communication.

This mannequin may even generate new dolphin-like sounds, just like how predictive textual content suggests the subsequent phrase in a sentence. This capability might assist establish the foundations governing dolphin communication and supply insights on understanding whether or not their vocalizations type a structured language.

DolphinGemma in Motion

What makes DolphinGemma notably efficient is its capability to run on units like Google Pixel telephones in real-time. With its light-weight structure, the mannequin can function with out the necessity for costly, specialised gear. Researchers can report dolphin sounds instantly on their telephones and instantly analyze them with DolphinGemma. This makes the expertise extra accessible and helps scale back analysis prices.

Moreover, DolphinGemma is built-in into the CHAT (Cetacean Listening to Augmentation Telemetry) system, which permits researchers to play artificial dolphin-like sounds and observe responses. This might result in the event of a shared vocabulary by enabling two-way communication between dolphins and people.

Broader Implications and Google’s Future Plan

The event of DolphinGemma is critical not just for understanding dolphin communication but additionally for advancing the research of animal cognition and communication. By decoding dolphin vocalizations, researchers can get deeper insights on dolphin social constructions, priorities, and thought processes. This might not solely enhance conservation efforts by understanding the wants and issues of dolphins but additionally has the potential to broaden our data about animal intelligence and consciousness.

DolphinGemma is a part of a broader motion utilizing AI to discover animal communication, with related efforts underway for species akin to crows, whales, and meerkats. Google plans to launch DolphinGemma as an open mannequin to the analysis group in the summertime of 2025, with the aim of extending its utility to different cetacean species, like bottlenose or spinner dolphins, via additional fine-tuning. This open-source method will encourage international collaboration in animal communication analysis. Google can be planning to check the mannequin within the area throughout the upcoming season which might additional broaden our understanding of Atlantic noticed dolphins.

Challenges and Scientific Skepticism

Regardless of its potential, DolphinGemma additionally faces a number of challenges. Ocean recordings are sometimes affected by background noise, making sound evaluation troublesome. Thad Starner from Georgia Tech, a researcher concerned on this mission, factors out that a lot of the information consists of ambient ocean sounds, requiring superior filtering strategies. Some researchers additionally query whether or not dolphin communication can really be thought of language. For instance, Arik Kershenbaum, a zoologist, means that, in contrast to the advanced nature of human language, dolphin vocalizations could also be a less complicated system of indicators. Thea Taylor, director of the Sussex Dolphin Undertaking, raises issues in regards to the threat of unintentionally coaching dolphins to imitate sounds. These views spotlight the necessity for rigorous validation and cautious interpretation of AI-generated insights.

The Backside Line

Google’s AI analysis into dolphin communication is a groundbreaking effort that brings us nearer to understanding the advanced methods dolphins work together with one another and their surroundings. By synthetic intelligence, researchers are detecting hidden patterns in dolphin sounds, providing new insights into their communication programs. Whereas challenges stay, the progress made up to now highlights the potential of AI in animal conduct research. As this analysis evolves, it might open doorways to new alternatives in conservation, animal cognition research, and human-animal interplay.

swift – Agora iOS SDK: Distant video not displaying for my part


I am attempting to show a distant display share video utilizing the Agora iOS SDK.
I am establishing the video canvas after receiving the didJoinedOfUid delegate, however the preview just isn’t exhibiting up.
That is my configuration for establishing my View.

    func createScreenShareView(uid: UInt, agoraEngine: AgoraRtcEngineKit) {
    guard isStreamActive else {
        print("FOO: Display share not lively. Skipping createScreenShareView.")
        return
    }
    print("FOO: Including remoteShareView to fundamental view for uid (uid)")
    view.addSubview(remoteShareView)
    view.bringSubviewToFront(remoteShareView)

    NSLayoutConstraint.activate([
        remoteShareView.centerXAnchor.constraint(equalTo: view.centerXAnchor),
        remoteShareView.centerYAnchor.constraint(equalTo: view.centerYAnchor),
        remoteShareView.widthAnchor.constraint(equalTo: view.widthAnchor),
        remoteShareView.heightAnchor.constraint(equalTo: view.heightAnchor),
    ])
    print("FOO: Activated constraints for remoteShareView")

    let videoCanvas = AgoraRtcVideoCanvas()
    videoCanvas.uid = uid
    videoCanvas.view = remoteShareView
    videoCanvas.renderMode = .match
    print("FOO: Establishing distant video for uid (uid)")
    agoraEngine.setupRemoteVideo(videoCanvas)
}

In my AgoraRtcEngineDelegate, I name a delegate technique to inform about receiving video stream and move the uid and engine to view controller.

func rtcEngine(_ engine: AgoraRtcEngineKit, didJoinedOfUid uid: UInt, elapsed: Int {
        self.uid = uid
               if let engine = agoraEngine {
            print("FOO: calling screenDelegate?.didJoinedOfUid for uid (uid)")
            screenDelegate?.didJoinedOfUid(uid: uid, elapsed: elapsed, agoraEngine: engine)
        }
    }

Right here is the implementation for that

 func didJoinedOfUid(uid: UInt, elapsed: Int, agoraEngine: AgoraRtcEngineKit) {
        print("FOO: didJoinedOfUid referred to as with uid (uid), elapsed (elapsed) ms")
        createScreenShareView(uid: uid, agoraEngine: agoraEngine)
    }

    func didOfflineOfUid(uid: UInt, agoraEngine: AgoraRtcEngineKit) {
        print("FOO: didOfflineOfUid referred to as with uid (uid)")
        stopSharing(uid: uid, agoraEngine: agoraEngine)
    }

The view is getting added and visual however distant video stream just isn’t being proven . This occurred once I shared from Android to iOS.

firebase – React-Native play a sound notification when the app is closed or within the background IOS


My challenge is that the notification sound works when the app is within the foreground, however it would not play when the app is within the background, despite the fact that the notification is acquired and displayed

1-Allow Capabilities in Xcode

2. Configure APNs in Firebase

  • Add your .p8 APNs Auth Key to the Firebase Console → Undertaking Settings → Cloud Messaging

3. Set up Required Libraries

npm set up @notifee/react-native @react-native-firebase/app @react-native-firebase/messaging
cd ios && pod set up && cd ..

4. Add Your Customized Sound File

  • Create a sound file in .caf, .aiff, or .wav

  • Instance: custom_sound.wav

  • Place it in ios/YourAppName/

  • Drag it into Xcode challenge navigator → guarantee “Copy if wanted” is checked

5. Ship Notification with Sound by way of FCM

{
  "to": "",
  "notification": {
    "title": "New Alert",
    "physique": "Sound take a look at",
    "sound": "custom_sound.wav"
  },
  "precedence": "excessive"
}
  • Do not embody silent: true or content_available: true

6. React Native: Show in Foreground

import messaging from '@react-native-firebase/messaging';
import notifee, {
  AndroidImportance,
  AndroidVisibility,
  EventType,
} from '@notifee/react-native';


async perform sendLocalNotification(message) {
  await notifee.requestPermission({ sound: true, alert: true });

  const channelId = await notifee.createChannel({
    id: 'default',
    identify: 'Default Channel',
    sound: 'default',
    significance: AndroidImportance.HIGH,
    visibility: AndroidVisibility.PRIVATE,
  });

  // Show a notification
  await notifee.displayNotification({
    title: message.notification.title,
    physique: message.notification.physique,
    information: message?.information,
    ios: {
      sound: 'custom_sound.wav',
    },
    android: {
      channelId,
      significance: AndroidImportance.HIGH,
      visibility: AndroidVisibility.PRIVATE,
      sound: 'custom_sound',
    },
  });
}

  const unsubscribe = messaging().onMessage(async notification => {
      sendLocalNotification(notification);
    });
 notifee.onForegroundEvent(async information => {
        const { kind, element } = information;
        swap (kind) {
          case EventType.DISMISSED:
            await notifee.cancelNotification(element.notification.id);
            break;
          case EventType.PRESS:
            handelNotification(
              element.notification.information,
              element.notification.id,
            );
            break;
        }
      });

7. Request Permission

useEffect(() => {
    NotifyPermissions();
}, []);

 async perform NotifyPermissions() {
    await messaging().requestPermission();
   }

This works completely for me; there isn’t any want for anything.

  "dependencies": {
    "@notifee/react-native": "^9.1.8",
    "@react-native-firebase/app": "18.6.1",
    "@react-native-firebase/messaging": "18.6.1",
    "react": "18.2.0",
    "react-native": "0.74.3",

}

ios – Xcode Builds Efficiently And Then Throws Error Stating Lacking Recordsdata


Re: iOS app.

After I set up pods through CLI to my undertaking for the primary time, launch Xcode, after which run the app, every part works effective – no construct errors.

However after a number of cases of operating the undertaking on my gadget, unexpectedly construct errors appear as if:

/Pods/FirebaseCrashlytics/Crashlytics/Crashlytics/Settings/Fashions/FIRCLSApplicationIdentifierModel.m:19:9 ‘Crashlytics/Shared/FIRCLSByteUtility.h’ file not discovered

/Pods/PostHog/vendor/libwebp/ph_sharpyuv_csp.h /Pods/PostHog/vendor/libwebp/ph_sharpyuv_csp.h: No such file or listing

And I do not know why if it is due to my PodFile or any Construct Settings/Phases/Guidelines, however this retains taking place repeatedly and it is unimaginable to develop something with this.

I’ve tried a string of instructions comparable to pod deintegrate, pod cache clear --all, eradicating PodFile.lock and operating pod set up once more, eradicating derived information, and cleansing construct folder.

I nonetheless maintain operating into the identical construct error and it is all the time after a number of builds this occurs, nothing is lacking prior when the undertaking efficiently builds.

Right here is my PodFile for reference:

# Uncomment the following line to outline a world platform on your undertaking
platform :ios, '17.0'

def google_utilities
  pod 'GoogleUtilities/AppDelegateSwizzler'
  pod 'GoogleUtilities/Atmosphere'
  pod 'GoogleUtilities/ISASwizzler'
  pod 'GoogleUtilities/Logger'
  pod 'GoogleUtilities/MethodSwizzler'
  pod 'GoogleUtilities/NSData+zlib'
  pod 'GoogleUtilities/Community'
  pod 'GoogleUtilities/Reachability'
  pod 'GoogleUtilities/UserDefaults'
finish


goal 'SE' do
  # Remark the following line in case you do not wish to use dynamic frameworks
  use_frameworks!

  # Pods for SE
    pod 'Firebase/Core'
    pod 'Firebase/Firestore'
    pod 'Firebase/Auth'

    google_utilities
finish

goal 'NSE' do
  # Remark the following line in case you do not wish to use dynamic frameworks
  use_frameworks!

  # Pods for NSE
    pod 'Firebase/Messaging'

    google_utilities
finish

goal 'targetApp' do
  # Remark the following line in case you do not wish to use dynamic frameworks
  use_frameworks!

  #Pods for targetApp
    pod 'Firebase/Core'
    pod 'Firebase/Crashlytics'
    pod 'Firebase/Messaging'
    pod 'Firebase/Firestore'
    pod 'Firebase/Storage'
    pod 'Firebase/Capabilities'
    pod 'PromiseKit', '~> 6.0'
    pod 'lottie-ios'
    pod 'GooglePlaces'
    pod 'JWTDecode', '~> 2.4'
    pod 'PostHog'
    pod 'Kingfisher', '~> 8.0'
    pod 'PhoneNumberKit'

    google_utilities

finish

post_install do |installer|

  installer.aggregate_targets.every do |goal|
    goal.xcconfigs.every do |variant, xcconfig|
      xcconfig_path = goal.client_root + goal.xcconfig_relative_path(variant)
      IO.write(xcconfig_path, IO.learn(xcconfig_path).gsub("DT_TOOLCHAIN_DIR", "TOOLCHAIN_DIR"))
    finish
  finish
  installer.pods_project.targets.every do |goal|
    goal.build_configurations.every do |config|
      if config.base_configuration_reference.is_a? Xcodeproj::Venture::Object::PBXFileReference
        xcconfig_path = config.base_configuration_reference.real_path
        IO.write(xcconfig_path, IO.learn(xcconfig_path).gsub("DT_TOOLCHAIN_DIR", "TOOLCHAIN_DIR"))
        config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = '17.0'
      finish
    finish
  finish
  installer.pods_project.targets.every do |goal|
    if goal.identify == 'BoringSSL-GRPC'
      goal.source_build_phase.information.every do |file|
        if file.settings && file.settings['COMPILER_FLAGS']
          flags = file.settings['COMPILER_FLAGS'].cut up
          flags.reject! flag
          file.settings['COMPILER_FLAGS'] = flags.be part of(' ')
        finish
      finish
    finish
  finish
finish

And right here is my solely “Run Script” in Construct Phases:

"${PODS_ROOT}/FirebaseCrashlytics/upload-symbols" 
  -gsp "${PROJECT_DIR}/targetApp/GoogleService-Data.plist" 
  -p ios 
  "${DWARF_DSYM_FOLDER_PATH}/${DWARF_DSYM_FILE_NAME}"